Loading...
Searching...
No Matches
shared.cc File Reference
`#include "threadconf.h"`
`#include <iostream>`
`#include "kernel/mod2.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 1619 of file shared.cc.

Data Fields
Job * | job |
int | num |
Scheduler * | scheduler |

## Macro Definition Documentation

## MAX_THREADS

#define MAX_THREADS 128

Definition at line 1329 of file shared.cc.

## Function Documentation

## pSingular_initialize_thread()

void pSingular_initialize_thread | ( |  | ) |

## systhreads()

int SI_MOD_INIT systhreads | ( | SModulFunctions * | fn | ) |

Definition at line 3073 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;
}
FALSE
#define FALSE
Definition auxiliary.h:97
LibThread::ThreadState
Definition shared.cc:1331
currPack
VAR package currPack
Definition ipid.cc:55
SModulFunctions::iiAddCproc
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition ipid.h:70
LibThread::readSyncVar
BOOLEAN readSyncVar(leftv result, leftv arg)
Definition shared.cc:1233
LibThread::getThreadPoolWorkers
static BOOLEAN getThreadPoolWorkers(leftv result, leftv arg)
Definition shared.cc:2244
LibThread::getTable
BOOLEAN getTable(leftv result, leftv arg)
Definition shared.cc:936
LibThread::type_thread
int type_thread
Definition shared.cc:236
LibThread::getThreadPoolConcurrency
static BOOLEAN getThreadPoolConcurrency(leftv result, leftv arg)
Definition shared.cc:2276
LibThread::type_region
int type_region
Definition shared.cc:228
LibThread::createThread
ThreadState * createThread(void *(*thread_func)(ThreadState *, void *), void *arg)
Definition shared.cc:1464
LibThread::setThreadPoolConcurrency
static BOOLEAN setThreadPoolConcurrency(leftv result, leftv arg)
Definition shared.cc:2291
LibThread::scheduleJob
static BOOLEAN scheduleJob(leftv result, leftv arg)
Definition shared.cc:2789
LibThread::makeSyncVar
BOOLEAN makeSyncVar(leftv result, leftv arg)
Definition shared.cc:849
LibThread::makeSharedList
BOOLEAN makeSharedList(leftv result, leftv arg)
Definition shared.cc:819
LibThread::getList
BOOLEAN getList(leftv result, leftv arg)
Definition shared.cc:1023
LibThread::type_atomic_list
int type_atomic_list
Definition shared.cc:234
LibThread::statChannel
BOOLEAN statChannel(leftv result, leftv arg)
Definition shared.cc:1166
LibThread::threadEval
BOOLEAN threadEval(leftv result, leftv arg)
Definition shared.cc:2922
LibThread::unlockRegion
BOOLEAN unlockRegion(leftv result, leftv arg)
Definition shared.cc:1115
LibThread::sendChannel
BOOLEAN sendChannel(leftv result, leftv arg)
Definition shared.cc:1130
LibThread::joinThread
void * joinThread(ThreadState *ts)
Definition shared.cc:1469
LibThread::startJob
Job * startJob(ThreadPool *pool, Job *job, leftv arg)
Definition shared.cc:2476
LibThread::setSharedName
BOOLEAN setSharedName(leftv result, leftv arg)
Definition shared.cc:3033
LibThread::writeSyncVar
BOOLEAN writeSyncVar(leftv result, leftv arg)
Definition shared.cc:1184
LibThread::makeAtomicTable
BOOLEAN makeAtomicTable(leftv result, leftv arg)
Definition shared.cc:773
LibThread::bindSharedObject
BOOLEAN bindSharedObject(leftv result, leftv arg)
Definition shared.cc:919
LibThread::lockRegion
BOOLEAN lockRegion(leftv result, leftv arg)
Definition shared.cc:1083
LibThread::currentJob
BOOLEAN currentJob(leftv result, leftv arg)
Definition shared.cc:2893
LibThread::thread_state
ThreadState * thread_state
Definition shared.cc:1361
LibThread::type_threadpool
int type_threadpool
Definition shared.cc:237
LibThread::type_job
int type_job
Definition shared.cc:238
LibThread::testTrigger
static BOOLEAN testTrigger(leftv result, leftv arg)
Definition shared.cc:2773
LibThread::createThreadPool
ThreadPool * createThreadPool(int threads, int prioThreads=0)
Definition shared.cc:2213
LibThread::threadExec
BOOLEAN threadExec(leftv result, leftv arg)
Definition shared.cc:2950
LibThread::putTable
BOOLEAN putTable(leftv result, leftv arg)
Definition shared.cc:996
LibThread::makeAtomicList
BOOLEAN makeAtomicList(leftv result, leftv arg)
Definition shared.cc:787
LibThread::createTrigger
static BOOLEAN createTrigger(leftv result, leftv arg)
Definition shared.cc:2687
LibThread::currentThreadPool
BOOLEAN currentThreadPool(leftv result, leftv arg)
Definition shared.cc:2329
LibThread::type_atomic_table
int type_atomic_table
Definition shared.cc:232
LibThread::setThreadPoolWorkers
static BOOLEAN setThreadPoolWorkers(leftv result, leftv arg)
Definition shared.cc:2261
LibThread::type_syncvar
int type_syncvar
Definition shared.cc:231
LibThread::updateTrigger
static BOOLEAN updateTrigger(leftv result, leftv arg)
Definition shared.cc:2730
LibThread::getSharedName
BOOLEAN getSharedName(leftv result, leftv arg)
Definition shared.cc:3051
LibThread::receiveChannel
BOOLEAN receiveChannel(leftv result, leftv arg)
Definition shared.cc:1147
LibThread::mainThread
BOOLEAN mainThread(leftv result, leftv arg)
Definition shared.cc:2914
LibThread::closeThreadPool
void closeThreadPool(ThreadPool *pool, bool wait)
Definition shared.cc:2324
LibThread::type_shared_table
int type_shared_table
Definition shared.cc:233
LibThread::type_channel
int type_channel
Definition shared.cc:230
LibThread::threadPoolExec
BOOLEAN threadPoolExec(leftv result, leftv arg)
Definition shared.cc:2978
LibThread::type_shared_list
int type_shared_list
Definition shared.cc:235
LibThread::setCurrentThreadPool
BOOLEAN setCurrentThreadPool(leftv result, leftv arg)
Definition shared.cc:2341
LibThread::regionLock
BOOLEAN regionLock(leftv result, leftv arg)
Definition shared.cc:1098
LibThread::threadID
BOOLEAN threadID(leftv result, leftv arg)
Definition shared.cc:2906
LibThread::makeRegionlockType
void makeRegionlockType(int &type, const char *name)
Definition shared.cc:1316
LibThread::makeSharedTable
BOOLEAN makeSharedTable(leftv result, leftv arg)
Definition shared.cc:801
LibThread::typeSharedObject
BOOLEAN typeSharedObject(leftv result, leftv arg)
Definition shared.cc:888
LibThread::createJob
Job * createJob(void(*func)(leftv result, leftv arg))
Definition shared.cc:2466
LibThread::statSyncVar
BOOLEAN statSyncVar(leftv result, leftv arg)
Definition shared.cc:1252
LibThread::master_lock
Lock master_lock(true)
LibThread::findSharedObject
SharedObject * findSharedObject(SharedObjectTable &table, Lock *lock, string &name)
Definition shared.cc:266
LibThread::type_regionlock
int type_regionlock
Definition shared.cc:229
LibThread::type_trigger
int type_trigger
Definition shared.cc:239
LibThread::makeChannel
BOOLEAN makeChannel(leftv result, leftv arg)
Definition shared.cc:836
LibThread::jobCancelled
static BOOLEAN jobCancelled(leftv result, leftv arg)
Definition shared.cc:2607
LibThread::chainTrigger
static BOOLEAN chainTrigger(leftv result, leftv arg)
Definition shared.cc:2752
LibThread::makeRegion
BOOLEAN makeRegion(leftv result, leftv arg)
Definition shared.cc:862
LibThread::putList
BOOLEAN putList(leftv result, leftv arg)
Definition shared.cc:1056
LibThread::createThreadPoolSet
static BOOLEAN createThreadPoolSet(leftv result, leftv arg)
Definition shared.cc:2161
LibThread::makeSharedType
void makeSharedType(int &type, const char *name)
Definition shared.cc:1301
LibThread::updateSyncVar
BOOLEAN updateSyncVar(leftv result, leftv arg)
Definition shared.cc:1204
LibThread::inTable
BOOLEAN inTable(leftv result, leftv arg)
Definition shared.cc:969
LibThread::threadResult
BOOLEAN threadResult(leftv result, leftv arg)
Definition shared.cc:3002
LibThread::cancelJob
void cancelJob(Job *job)
Definition shared.cc:2509
LibThread::waitJob
void waitJob(Job *job)
Definition shared.cc:2585
LinTree::init
void init()
Definition lintree.cc:864
MAX_THREADS
#define MAX_THREADS
Definition shared.cc:1329
MAX_TOK
@ MAX_TOK
Definition tok.h:220