static void* do_callMain(void* arg) {
main_ptr_t chpl_main = (main_ptr_t) arg;
// make sure this thread has thread-private data.
setup_main_thread_private_data();
// make sure that the lock report is set up.
if (blockreport)
initializeLockReportForThread();
chpl_main();
return NULL;
}
void chpl_task_executeTasksInList(void** p_task_list_void) {
task_pool_p* p_task_list_head = (task_pool_p*) p_task_list_void;
task_pool_p curr_ptask;
task_pool_p child_ptask;
//
// If we're serial, all the tasks have already been executed.
//
if (chpl_task_getSerial())
return;
curr_ptask = get_current_ptask();
while (*p_task_list_head != NULL) {
chpl_fn_p task_to_run_fun = NULL;
// begin critical section
chpl_thread_mutexLock(&threading_lock);
if ((child_ptask = *p_task_list_head) != NULL) {
task_to_run_fun = child_ptask->fun;
dequeue_task(child_ptask);
}
// end critical section
chpl_thread_mutexUnlock(&threading_lock);
if (task_to_run_fun == NULL)
continue;
set_current_ptask(child_ptask);
// begin critical section
chpl_thread_mutexLock(&extra_task_lock);
extra_task_cnt++;
// end critical section
chpl_thread_mutexUnlock(&extra_task_lock);
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_set_suspended(curr_ptask->id);
chpldev_taskTable_set_active(child_ptask->id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
if (blockreport)
initializeLockReportForThread();
chpl_task_do_callbacks(chpl_task_cb_event_kind_begin,
child_ptask->filename,
child_ptask->lineno,
child_ptask->id,
child_ptask->is_executeOn);
(*task_to_run_fun)(child_ptask->arg);
chpl_task_do_callbacks(chpl_task_cb_event_kind_end,
child_ptask->filename,
child_ptask->lineno,
child_ptask->id,
child_ptask->is_executeOn);
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_set_active(curr_ptask->id);
chpldev_taskTable_remove(child_ptask->id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
// begin critical section
chpl_thread_mutexLock(&extra_task_lock);
extra_task_cnt--;
// end critical section
chpl_thread_mutexUnlock(&extra_task_lock);
set_current_ptask(curr_ptask);
chpl_mem_free(child_ptask, 0, 0);
}
}
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;
}
//
// When we create a thread it runs this wrapper function, which just
// executes tasks out of the pool as they become available.
//
static void
thread_begin(void* ptask_void) {
task_pool_p ptask;
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);
chpl_thread_setPrivateData(tp);
tp->lockRprt = NULL;
if (blockreport)
initializeLockReportForThread();
while (true) {
//
// wait for a task to be present in the task pool
//
// In revision 22137, we investigated whether it was beneficial to
// implement this while loop in a hybrid style, where depending on
// the number of tasks available, idle threads would either yield or
// wait on a condition variable to waken them. Through analysis, we
// realized this could potential create a case where a thread would
// become stranded, waiting for a condition signal that would never
// come. A potential solution to this was to keep a count of threads
// that were waiting on the signal, but since there was a performance
// impact from keeping it as a hybrid as opposed to merely yielding,
// it was decided that we would return to the simple yield case.
while (!task_pool_head) {
if (set_block_loc(0, CHPL_FILE_IDX_IDLE_TASK)) {
// all other tasks appear to be blocked
struct timeval deadline, now;
gettimeofday(&deadline, NULL);
deadline.tv_sec += 1;
do {
chpl_thread_yield();
if (!task_pool_head)
gettimeofday(&now, NULL);
} while (!task_pool_head
&& (now.tv_sec < deadline.tv_sec
|| (now.tv_sec == deadline.tv_sec
&& now.tv_usec < deadline.tv_usec)));
if (!task_pool_head) {
check_for_deadlock();
}
}
else {
do {
chpl_thread_yield();
} while (!task_pool_head);
}
unset_block_loc();
}
//
// Just now the pool had at least one task in it. Lock and see if
// there's something still there.
//
chpl_thread_mutexLock(&threading_lock);
if (!task_pool_head) {
chpl_thread_mutexUnlock(&threading_lock);
continue;
}
//
// We've found a task to run.
//
if (blockreport)
progress_cnt++;
//
// start new task; increment running count and remove task from pool
// also add to task to task-table (structure in ChapelRuntime that keeps
// track of currently running tasks for task-reports on deadlock or
// Ctrl+C).
//
ptask = task_pool_head;
idle_thread_cnt--;
running_task_cnt++;
dequeue_task(ptask);
// end critical section
chpl_thread_mutexUnlock(&threading_lock);
tp->ptask = ptask;
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_set_active(ptask->id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
chpl_task_do_callbacks(chpl_task_cb_event_kind_begin,
ptask->filename,
ptask->lineno,
ptask->id,
ptask->is_executeOn);
(*ptask->fun)(ptask->arg);
chpl_task_do_callbacks(chpl_task_cb_event_kind_end,
ptask->filename,
ptask->lineno,
ptask->id,
ptask->is_executeOn);
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_remove(ptask->id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
tp->ptask = NULL;
chpl_mem_free(ptask, 0, 0);
// begin critical section
chpl_thread_mutexLock(&threading_lock);
//
// finished task; decrement running count and increment idle count
//
assert(running_task_cnt > 0);
running_task_cnt--;
idle_thread_cnt++;
// end critical section
chpl_thread_mutexUnlock(&threading_lock);
}
}
void chpl_task_executeTasksInList(void** p_task_list_void) {
task_pool_p* p_task_list_head = (task_pool_p*) p_task_list_void;
task_pool_p curr_ptask;
task_pool_p child_ptask;
// Note: this function needs to tolerate an empty task
// list. That will happen for coforalls inside a serial block, say.
curr_ptask = get_current_ptask();
while (*p_task_list_head != NULL) {
chpl_fn_p task_to_run_fun = NULL;
// begin critical section
chpl_thread_mutexLock(&threading_lock);
if ((child_ptask = *p_task_list_head) != NULL) {
task_to_run_fun = child_ptask->bundle.requested_fn;
dequeue_task(child_ptask);
}
// end critical section
chpl_thread_mutexUnlock(&threading_lock);
if (task_to_run_fun == NULL)
continue;
set_current_ptask(child_ptask);
// begin critical section
chpl_thread_mutexLock(&extra_task_lock);
extra_task_cnt++;
// end critical section
chpl_thread_mutexUnlock(&extra_task_lock);
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_set_suspended(curr_ptask->bundle.id);
chpldev_taskTable_set_active(child_ptask->bundle.id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
if (blockreport)
initializeLockReportForThread();
chpl_task_do_callbacks(chpl_task_cb_event_kind_begin,
child_ptask->bundle.requested_fid,
child_ptask->bundle.filename,
child_ptask->bundle.lineno,
child_ptask->bundle.id,
child_ptask->bundle.is_executeOn);
(*task_to_run_fun)(&child_ptask->bundle);
chpl_task_do_callbacks(chpl_task_cb_event_kind_end,
child_ptask->bundle.requested_fid,
child_ptask->bundle.filename,
child_ptask->bundle.lineno,
child_ptask->bundle.id,
child_ptask->bundle.is_executeOn);
if (do_taskReport) {
chpl_thread_mutexLock(&taskTable_lock);
chpldev_taskTable_set_active(curr_ptask->bundle.id);
chpldev_taskTable_remove(child_ptask->bundle.id);
chpl_thread_mutexUnlock(&taskTable_lock);
}
// begin critical section
chpl_thread_mutexLock(&extra_task_lock);
extra_task_cnt--;
// end critical section
chpl_thread_mutexUnlock(&extra_task_lock);
set_current_ptask(curr_ptask);
chpl_mem_free(child_ptask, 0, 0);
}
}
