shared.cc File Reference

#include "threadconf.h"
#include <iostream>
#include "kernel/mod2.h"
#include "Singular/ipid.h"
#include "Singular/ipshell.h"
#include "Singular/links/silink.h"
#include "Singular/lists.h"
#include "Singular/blackbox.h"
#include "Singular/feOpt.h"
#include "Singular/libsingular.h"
#include <cstring>
#include <string>
#include <errno.h>
#include <stdio.h>
#include <vector>
#include <map>
#include <iterator>
#include <queue>
#include <assert.h>
#include "thread.h"
#include "lintree.h"
#include "singthreads.h"

Go to the source code of this file.

Data Structures
class	LibThread::Command
class	LibThread::SharedObject
class	LibThread::Region
class	LibThread::Transactional
class	LibThread::TxTable
class	LibThread::TxList
class	LibThread::SingularChannel
class	LibThread::SingularSyncVar
class	LibThread::ThreadState
class	LibThread::InterpreterThread
class	LibThread::Job
struct	LibThread::JobCompare
class	LibThread::Trigger
struct	LibThread::SchedInfo
class	LibThread::ThreadPool
class	LibThread::Scheduler
class	LibThread::AccTrigger
class	LibThread::CountTrigger
class	LibThread::SetTrigger
class	LibThread::ProcTrigger
class	LibThread::EvalJob
class	LibThread::ExecJob
class	LibThread::ProcJob
class	LibThread::KernelJob
class	LibThread::RawKernelJob

Namespaces
namespace	LibThread

Macros
#define	MAX_THREADS   128

Typedefs
typedef std::map< std::string, SharedObject * >	LibThread::SharedObjectTable
typedef SharedObject *	LibThread::SharedObjectPtr
typedef SharedObjectPtr(*	LibThread::SharedConstructor) ()
typedef queue< Job * >	LibThread::JobQueue

Functions
void	pSingular_initialize_thread ()
void	LibThread::acquireShared (SharedObject *obj)
void	LibThread::releaseShared (SharedObject *obj)
SharedObject *	LibThread::makeSharedObject (SharedObjectTable &table, Lock *lock, int type, string &name, SharedConstructor scons)
SharedObject *	LibThread::findSharedObject (SharedObjectTable &table, Lock *lock, string &name)
void *	LibThread::shared_init (blackbox *b)
void *	LibThread::new_shared (SharedObject *obj)
void	LibThread::shared_destroy (blackbox *b, void *d)
void	LibThread::rlock_destroy (blackbox *b, void *d)
void *	LibThread::shared_copy (blackbox *b, void *d)
BOOLEAN	LibThread::shared_assign (leftv l, leftv r)
BOOLEAN	LibThread::rlock_assign (leftv l, leftv r)
BOOLEAN	LibThread::shared_check_assign (blackbox *b, leftv l, leftv r)
BOOLEAN	LibThread::shared_op2 (int op, leftv res, leftv a1, leftv a2)
BOOLEAN	LibThread::shared_op3 (int op, leftv res, leftv a1, leftv a2, leftv a3)
char *	LibThread::shared_string (blackbox *b, void *d)
char *	LibThread::rlock_string (blackbox *b, void *d)
void	LibThread::report (const char *fmt, const char *name)
int	LibThread::wrong_num_args (const char *name, leftv arg, int n)
int	LibThread::not_a_uri (const char *name, leftv arg)
int	LibThread::not_a_region (const char *name, leftv arg)
char *	LibThread::str (leftv arg)
SharedObject *	LibThread::consTable ()
SharedObject *	LibThread::consList ()
SharedObject *	LibThread::consChannel ()
SharedObject *	LibThread::consSyncVar ()
SharedObject *	LibThread::consRegion ()
static void	LibThread::appendArg (vector< leftv > &argv, string &s)
static void	LibThread::appendArg (vector< leftv > &argv, leftv arg)
static void	LibThread::appendArgCopy (vector< leftv > &argv, leftv arg)
static BOOLEAN	LibThread::executeProc (sleftv &result, const char *procname, const vector< leftv > &argv)
BOOLEAN	LibThread::makeAtomicTable (leftv result, leftv arg)
BOOLEAN	LibThread::makeAtomicList (leftv result, leftv arg)
BOOLEAN	LibThread::makeSharedTable (leftv result, leftv arg)
BOOLEAN	LibThread::makeSharedList (leftv result, leftv arg)
BOOLEAN	LibThread::makeChannel (leftv result, leftv arg)
BOOLEAN	LibThread::makeSyncVar (leftv result, leftv arg)
BOOLEAN	LibThread::makeRegion (leftv result, leftv arg)
BOOLEAN	LibThread::findSharedObject (leftv result, leftv arg)
BOOLEAN	LibThread::typeSharedObject (leftv result, leftv arg)
BOOLEAN	LibThread::bindSharedObject (leftv result, leftv arg)
BOOLEAN	LibThread::getTable (leftv result, leftv arg)
BOOLEAN	LibThread::inTable (leftv result, leftv arg)
BOOLEAN	LibThread::putTable (leftv result, leftv arg)
BOOLEAN	LibThread::getList (leftv result, leftv arg)
BOOLEAN	LibThread::putList (leftv result, leftv arg)
BOOLEAN	LibThread::lockRegion (leftv result, leftv arg)
BOOLEAN	LibThread::regionLock (leftv result, leftv arg)
BOOLEAN	LibThread::unlockRegion (leftv result, leftv arg)
BOOLEAN	LibThread::sendChannel (leftv result, leftv arg)
BOOLEAN	LibThread::receiveChannel (leftv result, leftv arg)
BOOLEAN	LibThread::statChannel (leftv result, leftv arg)
BOOLEAN	LibThread::writeSyncVar (leftv result, leftv arg)
BOOLEAN	LibThread::updateSyncVar (leftv result, leftv arg)
BOOLEAN	LibThread::readSyncVar (leftv result, leftv arg)
BOOLEAN	LibThread::statSyncVar (leftv result, leftv arg)
void	LibThread::encode_shared (LinTree::LinTree &lintree, leftv val)
leftv	LibThread::decode_shared (LinTree::LinTree &lintree)
void	LibThread::ref_shared (LinTree::LinTree &lintree, int by)
void	LibThread::installShared (int type)
void	LibThread::makeSharedType (int &type, const char *name)
void	LibThread::makeRegionlockType (int &type, const char *name)
void	LibThread::setOption (int ch)
void	LibThread::thread_init ()
void *	LibThread::thread_main (void *arg)
void *	LibThread::interpreter_thread (ThreadState *ts, void *arg)
static ThreadState *	LibThread::newThread (void *(*thread_func)(ThreadState *, void *), void *arg, const char **error)
ThreadState *	LibThread::createThread (void *(*thread_func)(ThreadState *, void *), void *arg)
void *	LibThread::joinThread (ThreadState *ts)
static InterpreterThread *	LibThread::createInterpreterThread (const char **error)
static BOOLEAN	LibThread::createThread (leftv result, leftv arg)
static bool	LibThread::joinInterpreterThread (InterpreterThread *thread)
static BOOLEAN	LibThread::joinThread (leftv result, leftv arg)
static BOOLEAN	LibThread::createThreadPool (leftv result, leftv arg)
static BOOLEAN	LibThread::createThreadPoolSet (leftv result, leftv arg)
ThreadPool *	LibThread::createThreadPool (int threads, int prioThreads=0)
void	LibThread::release (ThreadPool *pool)
void	LibThread::retain (ThreadPool *pool)
ThreadPool *	LibThread::getCurrentThreadPool ()
static BOOLEAN	LibThread::getThreadPoolWorkers (leftv result, leftv arg)
static BOOLEAN	LibThread::setThreadPoolWorkers (leftv result, leftv arg)
static BOOLEAN	LibThread::getThreadPoolConcurrency (leftv result, leftv arg)
static BOOLEAN	LibThread::setThreadPoolConcurrency (leftv result, leftv arg)
static BOOLEAN	LibThread::closeThreadPool (leftv result, leftv arg)
void	LibThread::closeThreadPool (ThreadPool *pool, bool wait)
BOOLEAN	LibThread::currentThreadPool (leftv result, leftv arg)
BOOLEAN	LibThread::setCurrentThreadPool (leftv result, leftv arg)
static BOOLEAN	LibThread::createJob (leftv result, leftv arg)
Job *	LibThread::createJob (void(*func)(leftv result, leftv arg))
Job *	LibThread::createJob (void(*func)(long ndeps, Job **deps))
Job *	LibThread::startJob (ThreadPool *pool, Job *job, leftv arg)
Job *	LibThread::startJob (ThreadPool *pool, Job *job)
void	LibThread::cancelJob (Job *job)
Job *	LibThread::getCurrentJob ()
static BOOLEAN	LibThread::startJob (leftv result, leftv arg)
static BOOLEAN	LibThread::waitJob (leftv result, leftv arg)
void	LibThread::waitJob (Job *job)
static BOOLEAN	LibThread::cancelJob (leftv result, leftv arg)
static BOOLEAN	LibThread::jobCancelled (leftv result, leftv arg)
bool	LibThread::getJobCancelled (Job *job)
bool	LibThread::getJobCancelled ()
void	LibThread::setJobData (Job *job, void *data)
void *	LibThread::getJobData (Job *job)
void	LibThread::addJobArgs (Job *job, leftv arg)
leftv	LibThread::getJobResult (Job *job)
const char *	LibThread::getJobName (Job *job)
void	LibThread::setJobName (Job *job, const char *name)
static BOOLEAN	LibThread::createTrigger (leftv result, leftv arg)
static BOOLEAN	LibThread::updateTrigger (leftv result, leftv arg)
static BOOLEAN	LibThread::chainTrigger (leftv result, leftv arg)
static BOOLEAN	LibThread::testTrigger (leftv result, leftv arg)
static BOOLEAN	LibThread::scheduleJob (leftv result, leftv arg)
BOOLEAN	LibThread::currentJob (leftv result, leftv arg)
BOOLEAN	LibThread::threadID (leftv result, leftv arg)
BOOLEAN	LibThread::mainThread (leftv result, leftv arg)
BOOLEAN	LibThread::threadEval (leftv result, leftv arg)
BOOLEAN	LibThread::threadExec (leftv result, leftv arg)
BOOLEAN	LibThread::threadPoolExec (leftv result, leftv arg)
BOOLEAN	LibThread::threadResult (leftv result, leftv arg)
BOOLEAN	LibThread::setSharedName (leftv result, leftv arg)
BOOLEAN	LibThread::getSharedName (leftv result, leftv arg)
int SI_MOD_INIT()	systhreads (SModulFunctions *fn)

Variables
const int	LibThread::have_threads = 0
Lock	LibThread::global_objects_lock
SharedObjectTable	LibThread::global_objects
Lock	LibThread::master_lock (true)
Lock	LibThread::name_lock (true)
VAR long	LibThread::thread_id
long	LibThread::thread_counter
int	LibThread::type_region
int	LibThread::type_regionlock
int	LibThread::type_channel
int	LibThread::type_syncvar
int	LibThread::type_atomic_table
int	LibThread::type_shared_table
int	LibThread::type_atomic_list
int	LibThread::type_shared_list
int	LibThread::type_thread
int	LibThread::type_threadpool
int	LibThread::type_job
int	LibThread::type_trigger
Lock	LibThread::thread_lock
ThreadState *	LibThread::thread_state
STATIC_VAR ThreadPool *	LibThread::currentThreadPoolRef
STATIC_VAR Job *	LibThread::currentJobRef

---

Data Structure Documentation

LibThread::SchedInfo

struct LibThread::SchedInfo

Definition at line 1624 of file shared.cc.

Data Fields
Job *	job
int	num
Scheduler *	scheduler

Macro Definition Documentation

MAX_THREADS

#define MAX_THREADS   128

Definition at line 1334 of file shared.cc.

Function Documentation

pSingular_initialize_thread()

void pSingular_initialize_thread

(

)

systhreads()

int SI_MOD_INIT() systhreads

(

SModulFunctions *

fn

)

Definition at line 3078 of file shared.cc.

{
  const char *libname = currPack->libname;
  if (!libname) libname = "";
  master_lock.lock();
  if (!thread_state)
    thread_state = new ThreadState[MAX_THREADS];
  makeSharedType(type_atomic_table, "atomic_table");
  makeSharedType(type_atomic_list, "atomic_list");
  makeSharedType(type_shared_table, "shared_table");
  makeSharedType(type_shared_list, "shared_list");
  makeSharedType(type_channel, "channel");
  makeSharedType(type_syncvar, "syncvar");
  makeSharedType(type_region, "region");
  makeSharedType(type_thread, "thread");
  makeSharedType(type_threadpool, "threadpool");
  makeSharedType(type_job, "job");
  makeSharedType(type_trigger, "trigger");
  makeRegionlockType(type_regionlock, "regionlock");
 
  fn->iiAddCproc(libname, "putTable", FALSE, putTable);
  fn->iiAddCproc(libname, "getTable", FALSE, getTable);
  fn->iiAddCproc(libname, "inTable", FALSE, inTable);
  fn->iiAddCproc(libname, "putList", FALSE, putList);
  fn->iiAddCproc(libname, "getList", FALSE, getList);
  fn->iiAddCproc(libname, "lockRegion", FALSE, lockRegion);
  fn->iiAddCproc(libname, "regionLock", FALSE, regionLock);
  fn->iiAddCproc(libname, "unlockRegion", FALSE, unlockRegion);
  fn->iiAddCproc(libname, "sendChannel", FALSE, sendChannel);
  fn->iiAddCproc(libname, "receiveChannel", FALSE, receiveChannel);
  fn->iiAddCproc(libname, "statChannel", FALSE, statChannel);
  fn->iiAddCproc(libname, "writeSyncVar", FALSE, writeSyncVar);
  fn->iiAddCproc(libname, "updateSyncVar", FALSE, updateSyncVar);
  fn->iiAddCproc(libname, "readSyncVar", FALSE, readSyncVar);
  fn->iiAddCproc(libname, "statSyncVar", FALSE, statSyncVar);
 
  fn->iiAddCproc(libname, "makeAtomicTable", FALSE, makeAtomicTable);
  fn->iiAddCproc(libname, "makeAtomicList", FALSE, makeAtomicList);
  fn->iiAddCproc(libname, "makeSharedTable", FALSE, makeSharedTable);
  fn->iiAddCproc(libname, "makeSharedList", FALSE, makeSharedList);
  fn->iiAddCproc(libname, "makeChannel", FALSE, makeChannel);
  fn->iiAddCproc(libname, "makeSyncVar", FALSE, makeSyncVar);
  fn->iiAddCproc(libname, "makeRegion", FALSE, makeRegion);
  fn->iiAddCproc(libname, "findSharedObject", FALSE, findSharedObject);
  fn->iiAddCproc(libname, "bindSharedObject", FALSE, bindSharedObject);
  fn->iiAddCproc(libname, "typeSharedObject", FALSE, typeSharedObject);
 
  fn->iiAddCproc(libname, "createThread", FALSE, createThread);
  fn->iiAddCproc(libname, "joinThread", FALSE, joinThread);
  fn->iiAddCproc(libname, "createThreadPool", FALSE, createThreadPool);
  fn->iiAddCproc(libname, "createThreadPoolSet", FALSE, createThreadPoolSet);
#if 0
  fn->iiAddCproc(libname, "adjoinThreadPool", FALSE, adjoinThreadPool);
  fn->iiAddCproc(libname, "getAdjoinedThreadPools", FALSE, getAdjoinedThreadPools);
#endif
  fn->iiAddCproc(libname, "closeThreadPool", FALSE, closeThreadPool);
  fn->iiAddCproc(libname, "getThreadPoolWorkers", FALSE, getThreadPoolWorkers);
  fn->iiAddCproc(libname, "setThreadPoolWorkers", FALSE, setThreadPoolWorkers);
  fn->iiAddCproc(libname, "getThreadPoolConcurrency", FALSE, getThreadPoolConcurrency);
  fn->iiAddCproc(libname, "setThreadPoolConcurrency", FALSE, setThreadPoolConcurrency);
  fn->iiAddCproc(libname, "currentThreadPool", FALSE, currentThreadPool);
  fn->iiAddCproc(libname, "setCurrentThreadPool", FALSE, setCurrentThreadPool);
  fn->iiAddCproc(libname, "threadPoolExec", FALSE, threadPoolExec);
  fn->iiAddCproc(libname, "threadID", FALSE, threadID);
  fn->iiAddCproc(libname, "mainThread", FALSE, mainThread);
  fn->iiAddCproc(libname, "threadEval", FALSE, threadEval);
  fn->iiAddCproc(libname, "threadExec", FALSE, threadExec);
  fn->iiAddCproc(libname, "threadResult", FALSE, threadResult);
  fn->iiAddCproc(libname, "createJob", FALSE, createJob);
  fn->iiAddCproc(libname, "currentJob", FALSE, currentJob);
  fn->iiAddCproc(libname, "setSharedName", FALSE, setSharedName);
  fn->iiAddCproc(libname, "getSharedName", FALSE, getSharedName);
  fn->iiAddCproc(libname, "startJob", FALSE, startJob);
  fn->iiAddCproc(libname, "waitJob", FALSE, waitJob);
  fn->iiAddCproc(libname, "cancelJob", FALSE, cancelJob);
  fn->iiAddCproc(libname, "jobCancelled", FALSE, jobCancelled);
  fn->iiAddCproc(libname, "scheduleJob", FALSE, scheduleJob);
  fn->iiAddCproc(libname, "scheduleJobs", FALSE, scheduleJob);
  fn->iiAddCproc(libname, "createTrigger", FALSE, createTrigger);
  fn->iiAddCproc(libname, "updateTrigger", FALSE, updateTrigger);
  fn->iiAddCproc(libname, "testTrigger", FALSE, testTrigger);
  fn->iiAddCproc(libname, "chainTrigger", FALSE, chainTrigger);
 
  LinTree::init();
  master_lock.unlock();
 
  return MAX_TOK;
}