//
// Get ID.
//
chpl_taskID_t chpl_task_getId(void) {
chpl_taskID_t tid;
enter_();
tid = (chpl_taskID_t)myth_self();
return_from_();
return tid;
}
chpl_bool chpl_sync_isFull(void * val_ptr, chpl_sync_aux_t * s) {
chpl_bool x;
enter_();
x = myth_felock_status(s->felock);
return_from_();
return x;
}
//
// Get and set dynamic serial state.
//
chpl_bool chpl_task_getSerial(void) {
void * r;
enter_();
r = myth_getspecific(myth_key_serial_state);
return_from_();
return (chpl_bool)r;
}
void chpl_task_init(void) {
size_t css;
int _ = enter_();
myth_globalattr_t attr[1];
int r = myth_globalattr_init(attr);
(void)_; (void)r;
assert(r == 0);
/* set call stack size */
css = chpl_task_getEnvCallStackSize();
if (css) {
myth_globalattr_set_stacksize(attr, css);
} else {
/* chpl_task_getDefaultCallStackSize() generally returns
a too larger value. we do not use it.
this essentially uses MassiveThreads default stack size */
#if 0
css = chpl_task_getDefaultCallStackSize();
myth_globalattr_set_stacksize(attr, css);
#endif
}
myth_init_ex(attr);
r = myth_key_create(&myth_key_serial_state, 0);
assert(r == 0);
(void)r;
return_from_();
}
void chpl_task_sleep(double secs) {
double t, end_t;
enter_();
t = cur_time();
end_t = t + secs;
while (t < end_t) {
myth_yield();
t = cur_time();
}
return_from_();
}
//
// Call a function in a task.
//
void chpl_task_taskCallFTable(chpl_fn_int_t fid, // function to call
//void* arg, // function arg
chpl_task_bundle_t* arg,// function arg
size_t arg_size, // length of arg
c_sublocid_t subloc, // desired sublocale
int lineno, // line at which function begins
int32_t filename) { // name of file containing function
enter_();
myth_chpl_create(/* is_executeOn = */ false,
lineno, filename,
subloc, fid, get_next_task_id(), arg, arg_size);
return_from_();
}
//
// Launch a task that is the logical continuation of some other task,
// but on a different locale. This is used to invoke the body of an
// "on" statement.
//
void chpl_task_startMovedTask(chpl_fn_int_t fid, // function to call
chpl_fn_p fp,
//void* arg, // function arg
chpl_task_bundle_t* arg,// function arg
size_t arg_size, // length of arg in bytes
c_sublocid_t subloc, // desired sublocale
chpl_taskID_t id // task identifier
) {
enter_();
myth_chpl_create(/* is_executeOn = */ true,
0, CHPL_FILE_IDX_UNKNOWN,
subloc, fid, id, arg, arg_size);
return_from_();
}
//
// Task list processing. These are called by the compiler-emitted
// code for all parallel constructs. addToTaskList() is called for
// each task and builds a list of all of them. processTaskList()
// actually adds the tasks to the task pool. executeTasksInList()
// makes sure all the tasks have at least started. freeTaskList()
// just reclaims space associated with the list.
//
void chpl_task_addToTaskList(
chpl_fn_int_t fid, // function to call for task
//void* arg, // argument to the function
chpl_task_bundle_t* arg, size_t arg_size,
c_sublocid_t subloc, // desired sublocale
void** p_task_list_void, // task list
c_nodeid_t task_list_locale, // locale (node) where task list resides
chpl_bool is_begin_stmt, // is begin{} stmt? (vs. cobegin or coforall)
int lineno, // line at which function begins
int32_t filename) { // name of file containing function
enter_();
myth_chpl_create(/* is_executeOn = */ false,
lineno, filename,
subloc, fid, get_next_task_id(), arg, arg_size);
return_from_();
}
//
// Launch a task that is the logical continuation of some other task,
// but on a different locale. This is used to invoke the body of an
// "on" statement.
//
void chpl_task_startMovedTask(chpl_fn_int_t fid, // function to call
chpl_fn_p fp,
//void* arg, // function arg
chpl_task_bundle_t* arg,// function arg
size_t arg_size, // length of arg in bytes
c_sublocid_t subloc, // desired sublocale
chpl_taskID_t id, // task identifier
chpl_bool serial_state) { // serial state
enter_();
if (chpl_task_getSerial()) {
chpl_ftable[fid](arg);
} else {
myth_chpl_create(/* serial_state = */ false,
/* is_executeOn = */ true,
0, CHPL_FILE_IDX_UNKNOWN,
subloc, fid, id, arg, arg_size);
}
return_from_();
}
void chpl_task_setSerial(chpl_bool state) {
enter_();
myth_setspecific(myth_key_serial_state, (void *)state);
return_from_();
}
c_sublocid_t chpl_task_getRequestedSubloc(void) {
enter_();
return_from_();
return c_sublocid_any;
}
void chpl_task_setSubloc(c_sublocid_t subloc) {
enter_();
return_from_();
}
c_sublocid_t chpl_task_getSubloc(void) {
enter_();
return_from_();
return 0;
}
void chpl_sync_markAndSignalEmpty(chpl_sync_aux_t * s) {
enter_();
myth_felock_mark_and_signal(s->felock, 0);
return_from_();
}
void chpl_task_exit(void) {
// called by the main task
enter_();
myth_fini();
return_from_();
}
void chpl_sync_destroyAux(chpl_sync_aux_t * s) {
enter_();
myth_felock_destroy(s->felock);
return_from_();
}
void chpl_sync_initAux(chpl_sync_aux_t * s) {
enter_();
myth_felock_init(s->felock, 0);
return_from_();
}
void chpl_sync_unlock(chpl_sync_aux_t * s) {
enter_();
myth_felock_unlock(s->felock);
return_from_();
}
//
// Yield.
//
void chpl_task_yield(void) {
enter_();
myth_yield();
return_from_();
}
void chpl_task_executeTasksInList(void** p_task_list_void) {
enter_();
return_from_();
}
//
// Have the tasking layer call the 'chpl_main' function pointer
// representing the entry point for the user's Chapel code. This
// can either be done by invoking the function directly or by creating
// a task that evaluates the function.
//
void chpl_task_callMain(void (*chpl_main)(void)) {
enter_();
chpl_main();
return_from_();
}
void chpl_sync_waitEmptyAndLock(chpl_sync_aux_t * s,
int32_t lineno, int32_t filename) {
enter_();
myth_felock_wait_and_lock(s->felock, 0);
return_from_();
}
