My Project
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 SharedObjectLibThread::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)
 
SharedObjectLibThread::makeSharedObject (SharedObjectTable &table, Lock *lock, int type, string &name, SharedConstructor scons)
 
SharedObjectLibThread::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)
 
SharedObjectLibThread::consTable ()
 
SharedObjectLibThread::consList ()
 
SharedObjectLibThread::consChannel ()
 
SharedObjectLibThread::consSyncVar ()
 
SharedObjectLibThread::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 ThreadStateLibThread::newThread (void *(*thread_func)(ThreadState *, void *), void *arg, const char **error)
 
ThreadStateLibThread::createThread (void *(*thread_func)(ThreadState *, void *), void *arg)
 
void * LibThread::joinThread (ThreadState *ts)
 
static InterpreterThreadLibThread::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)
 
ThreadPoolLibThread::createThreadPool (int threads, int prioThreads=0)
 
void LibThread::release (ThreadPool *pool)
 
void LibThread::retain (ThreadPool *pool)
 
ThreadPoolLibThread::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)
 
JobLibThread::createJob (void(*func)(leftv result, leftv arg))
 
JobLibThread::createJob (void(*func)(long ndeps, Job **deps))
 
JobLibThread::startJob (ThreadPool *pool, Job *job, leftv arg)
 
JobLibThread::startJob (ThreadPool *pool, Job *job)
 
void LibThread::cancelJob (Job *job)
 
JobLibThread::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
 
ThreadStateLibThread::thread_state
 
STATIC_VAR ThreadPoolLibThread::currentThreadPoolRef
 
STATIC_VAR JobLibThread::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.

3074{
3075 const char *libname = currPack->libname;
3076 if (!libname) libname = "";
3077 master_lock.lock();
3078 if (!thread_state)
3080 makeSharedType(type_atomic_table, "atomic_table");
3081 makeSharedType(type_atomic_list, "atomic_list");
3082 makeSharedType(type_shared_table, "shared_table");
3083 makeSharedType(type_shared_list, "shared_list");
3084 makeSharedType(type_channel, "channel");
3085 makeSharedType(type_syncvar, "syncvar");
3086 makeSharedType(type_region, "region");
3087 makeSharedType(type_thread, "thread");
3088 makeSharedType(type_threadpool, "threadpool");
3089 makeSharedType(type_job, "job");
3090 makeSharedType(type_trigger, "trigger");
3091 makeRegionlockType(type_regionlock, "regionlock");
3092
3093 fn->iiAddCproc(libname, "putTable", FALSE, putTable);
3094 fn->iiAddCproc(libname, "getTable", FALSE, getTable);
3095 fn->iiAddCproc(libname, "inTable", FALSE, inTable);
3096 fn->iiAddCproc(libname, "putList", FALSE, putList);
3097 fn->iiAddCproc(libname, "getList", FALSE, getList);
3098 fn->iiAddCproc(libname, "lockRegion", FALSE, lockRegion);
3099 fn->iiAddCproc(libname, "regionLock", FALSE, regionLock);
3100 fn->iiAddCproc(libname, "unlockRegion", FALSE, unlockRegion);
3101 fn->iiAddCproc(libname, "sendChannel", FALSE, sendChannel);
3102 fn->iiAddCproc(libname, "receiveChannel", FALSE, receiveChannel);
3103 fn->iiAddCproc(libname, "statChannel", FALSE, statChannel);
3104 fn->iiAddCproc(libname, "writeSyncVar", FALSE, writeSyncVar);
3105 fn->iiAddCproc(libname, "updateSyncVar", FALSE, updateSyncVar);
3106 fn->iiAddCproc(libname, "readSyncVar", FALSE, readSyncVar);
3107 fn->iiAddCproc(libname, "statSyncVar", FALSE, statSyncVar);
3108
3109 fn->iiAddCproc(libname, "makeAtomicTable", FALSE, makeAtomicTable);
3110 fn->iiAddCproc(libname, "makeAtomicList", FALSE, makeAtomicList);
3111 fn->iiAddCproc(libname, "makeSharedTable", FALSE, makeSharedTable);
3112 fn->iiAddCproc(libname, "makeSharedList", FALSE, makeSharedList);
3113 fn->iiAddCproc(libname, "makeChannel", FALSE, makeChannel);
3114 fn->iiAddCproc(libname, "makeSyncVar", FALSE, makeSyncVar);
3115 fn->iiAddCproc(libname, "makeRegion", FALSE, makeRegion);
3116 fn->iiAddCproc(libname, "findSharedObject", FALSE, findSharedObject);
3117 fn->iiAddCproc(libname, "bindSharedObject", FALSE, bindSharedObject);
3118 fn->iiAddCproc(libname, "typeSharedObject", FALSE, typeSharedObject);
3119
3120 fn->iiAddCproc(libname, "createThread", FALSE, createThread);
3121 fn->iiAddCproc(libname, "joinThread", FALSE, joinThread);
3122 fn->iiAddCproc(libname, "createThreadPool", FALSE, createThreadPool);
3123 fn->iiAddCproc(libname, "createThreadPoolSet", FALSE, createThreadPoolSet);
3124#if 0
3125 fn->iiAddCproc(libname, "adjoinThreadPool", FALSE, adjoinThreadPool);
3126 fn->iiAddCproc(libname, "getAdjoinedThreadPools", FALSE, getAdjoinedThreadPools);
3127#endif
3128 fn->iiAddCproc(libname, "closeThreadPool", FALSE, closeThreadPool);
3129 fn->iiAddCproc(libname, "getThreadPoolWorkers", FALSE, getThreadPoolWorkers);
3130 fn->iiAddCproc(libname, "setThreadPoolWorkers", FALSE, setThreadPoolWorkers);
3131 fn->iiAddCproc(libname, "getThreadPoolConcurrency", FALSE, getThreadPoolConcurrency);
3132 fn->iiAddCproc(libname, "setThreadPoolConcurrency", FALSE, setThreadPoolConcurrency);
3133 fn->iiAddCproc(libname, "currentThreadPool", FALSE, currentThreadPool);
3134 fn->iiAddCproc(libname, "setCurrentThreadPool", FALSE, setCurrentThreadPool);
3135 fn->iiAddCproc(libname, "threadPoolExec", FALSE, threadPoolExec);
3136 fn->iiAddCproc(libname, "threadID", FALSE, threadID);
3137 fn->iiAddCproc(libname, "mainThread", FALSE, mainThread);
3138 fn->iiAddCproc(libname, "threadEval", FALSE, threadEval);
3139 fn->iiAddCproc(libname, "threadExec", FALSE, threadExec);
3140 fn->iiAddCproc(libname, "threadResult", FALSE, threadResult);
3141 fn->iiAddCproc(libname, "createJob", FALSE, createJob);
3142 fn->iiAddCproc(libname, "currentJob", FALSE, currentJob);
3143 fn->iiAddCproc(libname, "setSharedName", FALSE, setSharedName);
3144 fn->iiAddCproc(libname, "getSharedName", FALSE, getSharedName);
3145 fn->iiAddCproc(libname, "startJob", FALSE, startJob);
3146 fn->iiAddCproc(libname, "waitJob", FALSE, waitJob);
3147 fn->iiAddCproc(libname, "cancelJob", FALSE, cancelJob);
3148 fn->iiAddCproc(libname, "jobCancelled", FALSE, jobCancelled);
3149 fn->iiAddCproc(libname, "scheduleJob", FALSE, scheduleJob);
3150 fn->iiAddCproc(libname, "scheduleJobs", FALSE, scheduleJob);
3151 fn->iiAddCproc(libname, "createTrigger", FALSE, createTrigger);
3152 fn->iiAddCproc(libname, "updateTrigger", FALSE, updateTrigger);
3153 fn->iiAddCproc(libname, "testTrigger", FALSE, testTrigger);
3154 fn->iiAddCproc(libname, "chainTrigger", FALSE, chainTrigger);
3155
3156 LinTree::init();
3157 master_lock.unlock();
3158
3159 return MAX_TOK;
3160}
#define FALSE
Definition auxiliary.h:97
VAR package currPack
Definition ipid.cc:55
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition ipid.h:70
BOOLEAN readSyncVar(leftv result, leftv arg)
Definition shared.cc:1233
static BOOLEAN getThreadPoolWorkers(leftv result, leftv arg)
Definition shared.cc:2244
BOOLEAN getTable(leftv result, leftv arg)
Definition shared.cc:936
int type_thread
Definition shared.cc:236
static BOOLEAN getThreadPoolConcurrency(leftv result, leftv arg)
Definition shared.cc:2276
int type_region
Definition shared.cc:228
ThreadState * createThread(void *(*thread_func)(ThreadState *, void *), void *arg)
Definition shared.cc:1464
static BOOLEAN setThreadPoolConcurrency(leftv result, leftv arg)
Definition shared.cc:2291
static BOOLEAN scheduleJob(leftv result, leftv arg)
Definition shared.cc:2789
BOOLEAN makeSyncVar(leftv result, leftv arg)
Definition shared.cc:849
BOOLEAN makeSharedList(leftv result, leftv arg)
Definition shared.cc:819
BOOLEAN getList(leftv result, leftv arg)
Definition shared.cc:1023
int type_atomic_list
Definition shared.cc:234
BOOLEAN statChannel(leftv result, leftv arg)
Definition shared.cc:1166
BOOLEAN threadEval(leftv result, leftv arg)
Definition shared.cc:2922
BOOLEAN unlockRegion(leftv result, leftv arg)
Definition shared.cc:1115
BOOLEAN sendChannel(leftv result, leftv arg)
Definition shared.cc:1130
void * joinThread(ThreadState *ts)
Definition shared.cc:1469
Job * startJob(ThreadPool *pool, Job *job, leftv arg)
Definition shared.cc:2476
BOOLEAN setSharedName(leftv result, leftv arg)
Definition shared.cc:3033
BOOLEAN writeSyncVar(leftv result, leftv arg)
Definition shared.cc:1184
BOOLEAN makeAtomicTable(leftv result, leftv arg)
Definition shared.cc:773
BOOLEAN bindSharedObject(leftv result, leftv arg)
Definition shared.cc:919
BOOLEAN lockRegion(leftv result, leftv arg)
Definition shared.cc:1083
BOOLEAN currentJob(leftv result, leftv arg)
Definition shared.cc:2893
ThreadState * thread_state
Definition shared.cc:1361
int type_threadpool
Definition shared.cc:237
int type_job
Definition shared.cc:238
static BOOLEAN testTrigger(leftv result, leftv arg)
Definition shared.cc:2773
ThreadPool * createThreadPool(int threads, int prioThreads=0)
Definition shared.cc:2213
BOOLEAN threadExec(leftv result, leftv arg)
Definition shared.cc:2950
BOOLEAN putTable(leftv result, leftv arg)
Definition shared.cc:996
BOOLEAN makeAtomicList(leftv result, leftv arg)
Definition shared.cc:787
static BOOLEAN createTrigger(leftv result, leftv arg)
Definition shared.cc:2687
BOOLEAN currentThreadPool(leftv result, leftv arg)
Definition shared.cc:2329
int type_atomic_table
Definition shared.cc:232
static BOOLEAN setThreadPoolWorkers(leftv result, leftv arg)
Definition shared.cc:2261
int type_syncvar
Definition shared.cc:231
static BOOLEAN updateTrigger(leftv result, leftv arg)
Definition shared.cc:2730
BOOLEAN getSharedName(leftv result, leftv arg)
Definition shared.cc:3051
BOOLEAN receiveChannel(leftv result, leftv arg)
Definition shared.cc:1147
BOOLEAN mainThread(leftv result, leftv arg)
Definition shared.cc:2914
void closeThreadPool(ThreadPool *pool, bool wait)
Definition shared.cc:2324
int type_shared_table
Definition shared.cc:233
int type_channel
Definition shared.cc:230
BOOLEAN threadPoolExec(leftv result, leftv arg)
Definition shared.cc:2978
int type_shared_list
Definition shared.cc:235
BOOLEAN setCurrentThreadPool(leftv result, leftv arg)
Definition shared.cc:2341
BOOLEAN regionLock(leftv result, leftv arg)
Definition shared.cc:1098
BOOLEAN threadID(leftv result, leftv arg)
Definition shared.cc:2906
void makeRegionlockType(int &type, const char *name)
Definition shared.cc:1316
BOOLEAN makeSharedTable(leftv result, leftv arg)
Definition shared.cc:801
BOOLEAN typeSharedObject(leftv result, leftv arg)
Definition shared.cc:888
Job * createJob(void(*func)(leftv result, leftv arg))
Definition shared.cc:2466
BOOLEAN statSyncVar(leftv result, leftv arg)
Definition shared.cc:1252
Lock master_lock(true)
SharedObject * findSharedObject(SharedObjectTable &table, Lock *lock, string &name)
Definition shared.cc:266
int type_regionlock
Definition shared.cc:229
int type_trigger
Definition shared.cc:239
BOOLEAN makeChannel(leftv result, leftv arg)
Definition shared.cc:836
static BOOLEAN jobCancelled(leftv result, leftv arg)
Definition shared.cc:2607
static BOOLEAN chainTrigger(leftv result, leftv arg)
Definition shared.cc:2752
BOOLEAN makeRegion(leftv result, leftv arg)
Definition shared.cc:862
BOOLEAN putList(leftv result, leftv arg)
Definition shared.cc:1056
static BOOLEAN createThreadPoolSet(leftv result, leftv arg)
Definition shared.cc:2161
void makeSharedType(int &type, const char *name)
Definition shared.cc:1301
BOOLEAN updateSyncVar(leftv result, leftv arg)
Definition shared.cc:1204
BOOLEAN inTable(leftv result, leftv arg)
Definition shared.cc:969
BOOLEAN threadResult(leftv result, leftv arg)
Definition shared.cc:3002
void cancelJob(Job *job)
Definition shared.cc:2509
void waitJob(Job *job)
Definition shared.cc:2585
void init()
Definition lintree.cc:864
#define MAX_THREADS
Definition shared.cc:1329
@ MAX_TOK
Definition tok.h:220