chpl_thread_mutex_p chpl_thread_mutexNew(void) {
chpl_thread_mutex_p m;
m = (chpl_thread_mutex_p) chpl_mem_alloc(sizeof(chpl_thread_mutex_t),
CHPL_RT_MD_MUTEX, 0, 0);
chpl_thread_mutexInit(m);
return m;
}
void chpl_task_stdModulesInitialized(void) {
//
// The task table is implemented in Chapel code in the modules, so
// we can't use it, and thus can't support task reporting on ^C or
// deadlock, until the other modules on which it depends have been
// initialized and the supporting code here is set up. In this
// function we're guaranteed that is true, because it is called only
// after all the standard module initialization is complete.
//
//
// Register this main task in the task table.
//
if (taskreport) {
thread_private_data_t* tp = chpl_thread_getPrivateData();
chpldev_taskTable_add(tp->ptask->bundle.id,
tp->ptask->bundle.lineno, tp->ptask->bundle.filename,
(uint64_t) (intptr_t) tp->ptask);
chpldev_taskTable_set_active(tp->ptask->bundle.id);
chpl_thread_mutexInit(&taskTable_lock);
}
//
// Now we can do task reporting if the user requested it.
//
do_taskReport = taskreport;
}
void chpl_task_init(void) {
chpl_thread_mutexInit(&threading_lock);
chpl_thread_mutexInit(&extra_task_lock);
chpl_thread_mutexInit(&task_id_lock);
chpl_thread_mutexInit(&task_list_lock);
queued_task_cnt = 0;
running_task_cnt = 1; // only main task running
blocked_thread_cnt = 0;
idle_thread_cnt = 0;
extra_task_cnt = 0;
task_pool_head = task_pool_tail = NULL;
chpl_thread_init(thread_begin, thread_end);
//
// Set main thread private data, so that things that require access
// to it, like chpl_task_getID() and chpl_task_setSerial(), can be
// called early (notably during standard module initialization).
//
// This needs to be done after the threading layer initialization,
// because it's based on thread layer capabilities, but before we
// install the signal handlers, because when those are invoked they
// may use the thread private data.
//
setup_main_thread_private_data();
if (blockreport) {
progress_cnt = 0;
chpl_thread_mutexInit(&block_report_lock);
}
if (blockreport || taskreport) {
signal(SIGINT, SIGINT_handler);
}
initialized = true;
}
void chpl_sync_initAux(chpl_sync_aux_t *s) {
s->is_full = false;
chpl_thread_mutexInit(&s->lock);
chpl_thread_condvar_init(&s->signal_full);
chpl_thread_condvar_init(&s->signal_empty);
}
void chpl_task_init(void) {
chpl_thread_mutexInit(&threading_lock);
chpl_thread_mutexInit(&extra_task_lock);
chpl_thread_mutexInit(&task_id_lock);
chpl_thread_mutexInit(&task_list_lock);
queued_task_cnt = 0;
running_task_cnt = 1; // only main task running
blocked_thread_cnt = 0;
idle_thread_cnt = 0;
extra_task_cnt = 0;
task_pool_head = task_pool_tail = NULL;
chpl_thread_init(thread_begin, thread_end);
//
// Set main thread private data, so that things that require access
// to it, like chpl_task_getID() and chpl_task_setSerial(), can be
// called early (notably during standard module initialization).
//
// This needs to be done after the threading layer initialization,
// because it's based on thread layer capabilities, but before we
// install the signal handlers, because when those are invoked they
// may use the thread private data.
//
{
thread_private_data_t* tp;
tp = (thread_private_data_t*) chpl_mem_alloc(sizeof(thread_private_data_t),
CHPL_RT_MD_THREAD_PRV_DATA,
0, 0);
tp->ptask = (task_pool_p) chpl_mem_alloc(sizeof(task_pool_t),
CHPL_RT_MD_TASK_POOL_DESC,
0, 0);
tp->ptask->id = get_next_task_id();
tp->ptask->fun = NULL;
tp->ptask->arg = NULL;
tp->ptask->is_executeOn = false;
tp->ptask->filename = CHPL_FILE_IDX_MAIN_PROGRAM;
tp->ptask->lineno = 0;
tp->ptask->p_list_head = NULL;
tp->ptask->next = NULL;
tp->lockRprt = NULL;
// Set up task-private data for locale (architectural) support.
tp->ptask->chpl_data.prvdata.serial_state = true; // Set to false in chpl_task_callMain().
chpl_thread_setPrivateData(tp);
}
if (blockreport) {
progress_cnt = 0;
chpl_thread_mutexInit(&block_report_lock);
initializeLockReportForThread();
}
if (blockreport || taskreport) {
signal(SIGINT, SIGINT_handler);
}
initialized = true;
}
