My Project
Data Structures | Namespaces | Macros | Typedefs | Functions | Variables
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 3080 of file shared.cc.

3081{
3082 const char *libname = currPack->libname;
3083 if (!libname) libname = "";
3084 master_lock.lock();
3085 if (!thread_state)
3086 thread_state = new ThreadState[MAX_THREADS];
3087 makeSharedType(type_atomic_table, "atomic_table");
3088 makeSharedType(type_atomic_list, "atomic_list");
3089 makeSharedType(type_shared_table, "shared_table");
3090 makeSharedType(type_shared_list, "shared_list");
3091 makeSharedType(type_channel, "channel");
3092 makeSharedType(type_syncvar, "syncvar");
3093 makeSharedType(type_region, "region");
3094 makeSharedType(type_thread, "thread");
3095 makeSharedType(type_threadpool, "threadpool");
3096 makeSharedType(type_job, "job");
3097 makeSharedType(type_trigger, "trigger");
3098 makeRegionlockType(type_regionlock, "regionlock");
3099
3100 fn->iiAddCproc(libname, "putTable", FALSE, putTable);
3101 fn->iiAddCproc(libname, "getTable", FALSE, getTable);
3102 fn->iiAddCproc(libname, "inTable", FALSE, inTable);
3103 fn->iiAddCproc(libname, "putList", FALSE, putList);
3104 fn->iiAddCproc(libname, "getList", FALSE, getList);
3105 fn->iiAddCproc(libname, "lockRegion", FALSE, lockRegion);
3106 fn->iiAddCproc(libname, "regionLock", FALSE, regionLock);
3107 fn->iiAddCproc(libname, "unlockRegion", FALSE, unlockRegion);
3108 fn->iiAddCproc(libname, "sendChannel", FALSE, sendChannel);
3109 fn->iiAddCproc(libname, "receiveChannel", FALSE, receiveChannel);
3110 fn->iiAddCproc(libname, "statChannel", FALSE, statChannel);
3111 fn->iiAddCproc(libname, "writeSyncVar", FALSE, writeSyncVar);
3112 fn->iiAddCproc(libname, "updateSyncVar", FALSE, updateSyncVar);
3113 fn->iiAddCproc(libname, "readSyncVar", FALSE, readSyncVar);
3114 fn->iiAddCproc(libname, "statSyncVar", FALSE, statSyncVar);
3115
3116 fn->iiAddCproc(libname, "makeAtomicTable", FALSE, makeAtomicTable);
3117 fn->iiAddCproc(libname, "makeAtomicList", FALSE, makeAtomicList);
3118 fn->iiAddCproc(libname, "makeSharedTable", FALSE, makeSharedTable);
3119 fn->iiAddCproc(libname, "makeSharedList", FALSE, makeSharedList);
3120 fn->iiAddCproc(libname, "makeChannel", FALSE, makeChannel);
3121 fn->iiAddCproc(libname, "makeSyncVar", FALSE, makeSyncVar);
3122 fn->iiAddCproc(libname, "makeRegion", FALSE, makeRegion);
3123 fn->iiAddCproc(libname, "findSharedObject", FALSE, findSharedObject);
3124 fn->iiAddCproc(libname, "bindSharedObject", FALSE, bindSharedObject);
3125 fn->iiAddCproc(libname, "typeSharedObject", FALSE, typeSharedObject);
3126
3127 fn->iiAddCproc(libname, "createThread", FALSE, createThread);
3128 fn->iiAddCproc(libname, "joinThread", FALSE, joinThread);
3129 fn->iiAddCproc(libname, "createThreadPool", FALSE, createThreadPool);
3130 fn->iiAddCproc(libname, "createThreadPoolSet", FALSE, createThreadPoolSet);
3131#if 0
3132 fn->iiAddCproc(libname, "adjoinThreadPool", FALSE, adjoinThreadPool);
3133 fn->iiAddCproc(libname, "getAdjoinedThreadPools", FALSE, getAdjoinedThreadPools);
3134#endif
3135 fn->iiAddCproc(libname, "closeThreadPool", FALSE, closeThreadPool);
3136 fn->iiAddCproc(libname, "getThreadPoolWorkers", FALSE, getThreadPoolWorkers);
3137 fn->iiAddCproc(libname, "setThreadPoolWorkers", FALSE, setThreadPoolWorkers);
3138 fn->iiAddCproc(libname, "getThreadPoolConcurrency", FALSE, getThreadPoolConcurrency);
3139 fn->iiAddCproc(libname, "setThreadPoolConcurrency", FALSE, setThreadPoolConcurrency);
3140 fn->iiAddCproc(libname, "currentThreadPool", FALSE, currentThreadPool);
3141 fn->iiAddCproc(libname, "setCurrentThreadPool", FALSE, setCurrentThreadPool);
3142 fn->iiAddCproc(libname, "threadPoolExec", FALSE, threadPoolExec);
3143 fn->iiAddCproc(libname, "threadID", FALSE, threadID);
3144 fn->iiAddCproc(libname, "mainThread", FALSE, mainThread);
3145 fn->iiAddCproc(libname, "threadEval", FALSE, threadEval);
3146 fn->iiAddCproc(libname, "threadExec", FALSE, threadExec);
3147 fn->iiAddCproc(libname, "threadResult", FALSE, threadResult);
3148 fn->iiAddCproc(libname, "createJob", FALSE, createJob);
3149 fn->iiAddCproc(libname, "currentJob", FALSE, currentJob);
3150 fn->iiAddCproc(libname, "setSharedName", FALSE, setSharedName);
3151 fn->iiAddCproc(libname, "getSharedName", FALSE, getSharedName);
3152 fn->iiAddCproc(libname, "startJob", FALSE, startJob);
3153 fn->iiAddCproc(libname, "waitJob", FALSE, waitJob);
3154 fn->iiAddCproc(libname, "cancelJob", FALSE, cancelJob);
3155 fn->iiAddCproc(libname, "jobCancelled", FALSE, jobCancelled);
3156 fn->iiAddCproc(libname, "scheduleJob", FALSE, scheduleJob);
3157 fn->iiAddCproc(libname, "scheduleJobs", FALSE, scheduleJob);
3158 fn->iiAddCproc(libname, "createTrigger", FALSE, createTrigger);
3159 fn->iiAddCproc(libname, "updateTrigger", FALSE, updateTrigger);
3160 fn->iiAddCproc(libname, "testTrigger", FALSE, testTrigger);
3161 fn->iiAddCproc(libname, "chainTrigger", FALSE, chainTrigger);
3162
3163 LinTree::init();
3164 master_lock.unlock();
3165
3166 return MAX_TOK;
3167}
FALSE
#define FALSE
Definition: auxiliary.h:96
Lock::lock
void lock()
Definition: thread.h:46
Lock::unlock
void unlock()
Definition: thread.h:57
currPack
VAR package currPack
Definition: ipid.cc:57
getList
lists getList(spectrum &spec)
Definition: ipshell.cc:3399
LibThread::readSyncVar
BOOLEAN readSyncVar(leftv result, leftv arg)
Definition: shared.cc:1238
LibThread::createThread
static BOOLEAN createThread(leftv result, leftv arg)
Definition: shared.cc:1497
LibThread::getThreadPoolWorkers
static BOOLEAN getThreadPoolWorkers(leftv result, leftv arg)
Definition: shared.cc:2249
LibThread::getTable
BOOLEAN getTable(leftv result, leftv arg)
Definition: shared.cc:941
LibThread::type_thread
int type_thread
Definition: shared.cc:241
LibThread::getThreadPoolConcurrency
static BOOLEAN getThreadPoolConcurrency(leftv result, leftv arg)
Definition: shared.cc:2281
LibThread::waitJob
static BOOLEAN waitJob(leftv result, leftv arg)
Definition: shared.cc:2565
LibThread::type_region
int type_region
Definition: shared.cc:233
LibThread::createThreadPool
static BOOLEAN createThreadPool(leftv result, leftv arg)
Definition: shared.cc:2132
LibThread::setThreadPoolConcurrency
static BOOLEAN setThreadPoolConcurrency(leftv result, leftv arg)
Definition: shared.cc:2296
LibThread::scheduleJob
static BOOLEAN scheduleJob(leftv result, leftv arg)
Definition: shared.cc:2794
LibThread::makeSyncVar
BOOLEAN makeSyncVar(leftv result, leftv arg)
Definition: shared.cc:854
LibThread::makeSharedList
BOOLEAN makeSharedList(leftv result, leftv arg)
Definition: shared.cc:824
LibThread::type_atomic_list
int type_atomic_list
Definition: shared.cc:239
LibThread::statChannel
BOOLEAN statChannel(leftv result, leftv arg)
Definition: shared.cc:1171
LibThread::threadEval
BOOLEAN threadEval(leftv result, leftv arg)
Definition: shared.cc:2929
LibThread::unlockRegion
BOOLEAN unlockRegion(leftv result, leftv arg)
Definition: shared.cc:1120
LibThread::sendChannel
BOOLEAN sendChannel(leftv result, leftv arg)
Definition: shared.cc:1135
LibThread::setSharedName
BOOLEAN setSharedName(leftv result, leftv arg)
Definition: shared.cc:3040
LibThread::writeSyncVar
BOOLEAN writeSyncVar(leftv result, leftv arg)
Definition: shared.cc:1189
LibThread::makeAtomicTable
BOOLEAN makeAtomicTable(leftv result, leftv arg)
Definition: shared.cc:778
LibThread::startJob
static BOOLEAN startJob(leftv result, leftv arg)
Definition: shared.cc:2523
LibThread::bindSharedObject
BOOLEAN bindSharedObject(leftv result, leftv arg)
Definition: shared.cc:924
LibThread::lockRegion
BOOLEAN lockRegion(leftv result, leftv arg)
Definition: shared.cc:1088
LibThread::currentJob
BOOLEAN currentJob(leftv result, leftv arg)
Definition: shared.cc:2898
LibThread::thread_state
ThreadState * thread_state
Definition: shared.cc:1366
LibThread::type_threadpool
int type_threadpool
Definition: shared.cc:242
LibThread::type_job
int type_job
Definition: shared.cc:243
LibThread::testTrigger
static BOOLEAN testTrigger(leftv result, leftv arg)
Definition: shared.cc:2778
LibThread::createJob
static BOOLEAN createJob(leftv result, leftv arg)
Definition: shared.cc:2449
LibThread::threadExec
BOOLEAN threadExec(leftv result, leftv arg)
Definition: shared.cc:2957
LibThread::putTable
BOOLEAN putTable(leftv result, leftv arg)
Definition: shared.cc:1001
LibThread::makeAtomicList
BOOLEAN makeAtomicList(leftv result, leftv arg)
Definition: shared.cc:792
LibThread::createTrigger
static BOOLEAN createTrigger(leftv result, leftv arg)
Definition: shared.cc:2692
LibThread::currentThreadPool
BOOLEAN currentThreadPool(leftv result, leftv arg)
Definition: shared.cc:2334
LibThread::joinThread
static BOOLEAN joinThread(leftv result, leftv arg)
Definition: shared.cc:1531
LibThread::type_atomic_table
int type_atomic_table
Definition: shared.cc:237
LibThread::setThreadPoolWorkers
static BOOLEAN setThreadPoolWorkers(leftv result, leftv arg)
Definition: shared.cc:2266
LibThread::type_syncvar
int type_syncvar
Definition: shared.cc:236
LibThread::updateTrigger
static BOOLEAN updateTrigger(leftv result, leftv arg)
Definition: shared.cc:2735
LibThread::getSharedName
BOOLEAN getSharedName(leftv result, leftv arg)
Definition: shared.cc:3058
LibThread::receiveChannel
BOOLEAN receiveChannel(leftv result, leftv arg)
Definition: shared.cc:1152
LibThread::mainThread
BOOLEAN mainThread(leftv result, leftv arg)
Definition: shared.cc:2920
LibThread::type_shared_table
int type_shared_table
Definition: shared.cc:238
LibThread::type_channel
int type_channel
Definition: shared.cc:235
LibThread::threadPoolExec
BOOLEAN threadPoolExec(leftv result, leftv arg)
Definition: shared.cc:2985
LibThread::type_shared_list
int type_shared_list
Definition: shared.cc:240
LibThread::setCurrentThreadPool
BOOLEAN setCurrentThreadPool(leftv result, leftv arg)
Definition: shared.cc:2346
LibThread::regionLock
BOOLEAN regionLock(leftv result, leftv arg)
Definition: shared.cc:1103
LibThread::findSharedObject
BOOLEAN findSharedObject(leftv result, leftv arg)
Definition: shared.cc:880
LibThread::cancelJob
static BOOLEAN cancelJob(leftv result, leftv arg)
Definition: shared.cc:2595
LibThread::threadID
BOOLEAN threadID(leftv result, leftv arg)
Definition: shared.cc:2911
LibThread::makeRegionlockType
void makeRegionlockType(int &type, const char *name)
Definition: shared.cc:1321
LibThread::makeSharedTable
BOOLEAN makeSharedTable(leftv result, leftv arg)
Definition: shared.cc:806
LibThread::typeSharedObject
BOOLEAN typeSharedObject(leftv result, leftv arg)
Definition: shared.cc:893
LibThread::statSyncVar
BOOLEAN statSyncVar(leftv result, leftv arg)
Definition: shared.cc:1257
LibThread::master_lock
Lock master_lock(true)
LibThread::type_regionlock
int type_regionlock
Definition: shared.cc:234
LibThread::type_trigger
int type_trigger
Definition: shared.cc:244
LibThread::makeChannel
BOOLEAN makeChannel(leftv result, leftv arg)
Definition: shared.cc:841
LibThread::jobCancelled
static BOOLEAN jobCancelled(leftv result, leftv arg)
Definition: shared.cc:2612
LibThread::closeThreadPool
static BOOLEAN closeThreadPool(leftv result, leftv arg)
Definition: shared.cc:2313
LibThread::chainTrigger
static BOOLEAN chainTrigger(leftv result, leftv arg)
Definition: shared.cc:2757
LibThread::makeRegion
BOOLEAN makeRegion(leftv result, leftv arg)
Definition: shared.cc:867
LibThread::putList
BOOLEAN putList(leftv result, leftv arg)
Definition: shared.cc:1061
LibThread::createThreadPoolSet
static BOOLEAN createThreadPoolSet(leftv result, leftv arg)
Definition: shared.cc:2166
LibThread::makeSharedType
void makeSharedType(int &type, const char *name)
Definition: shared.cc:1306
LibThread::updateSyncVar
BOOLEAN updateSyncVar(leftv result, leftv arg)
Definition: shared.cc:1209
LibThread::inTable
BOOLEAN inTable(leftv result, leftv arg)
Definition: shared.cc:974
LibThread::threadResult
BOOLEAN threadResult(leftv result, leftv arg)
Definition: shared.cc:3009
LinTree::init
void init()
Definition: lintree.cc:864
MAX_THREADS
#define MAX_THREADS
Definition: shared.cc:1334
SModulFunctions::iiAddCproc
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:70
MAX_TOK
@ MAX_TOK
Definition: tok.h:218
Generated on Sun Apr 17 2022 10:44:00 for My Project by   doxygen 1.9.3 for Singular