void _starpu_wake_all_blocked_workers_on_node(unsigned nodeid)
{
/* wake up all workers on that memory node */
unsigned cond_id;
struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
unsigned nconds = descr->condition_count[nodeid];
for (cond_id = 0; cond_id < nconds; cond_id++)
{
struct _starpu_cond_and_mutex *condition;
condition = &descr->conditions_attached_to_node[nodeid][cond_id];
/* wake anybody waiting on that condition */
STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
STARPU_PTHREAD_COND_BROADCAST(condition->cond);
STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
}
STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
}
void starpu_wake_all_blocked_workers(void)
{
/* workers may be blocked on the various queues' conditions */
unsigned cond_id;
struct _starpu_memory_node_descr * const descr = _starpu_memory_node_get_description();
STARPU_PTHREAD_RWLOCK_RDLOCK(&descr->conditions_rwlock);
unsigned nconds = descr->total_condition_count;
for (cond_id = 0; cond_id < nconds; cond_id++)
{
struct _starpu_cond_and_mutex *condition;
condition = &descr->conditions_all[cond_id];
/* wake anybody waiting on that condition */
STARPU_PTHREAD_MUTEX_LOCK(condition->mutex);
STARPU_PTHREAD_COND_BROADCAST(condition->cond);
STARPU_PTHREAD_MUTEX_UNLOCK(condition->mutex);
}
STARPU_PTHREAD_RWLOCK_UNLOCK(&descr->conditions_rwlock);
}
int _starpu_push_task_to_workers(struct starpu_task *task)
{
struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(task->sched_ctx);
unsigned nworkers = 0;
_STARPU_TRACE_JOB_PUSH(task, task->priority > 0);
/* if the contexts still does not have workers put the task back to its place in
the empty ctx list */
if(!sched_ctx->is_initial_sched)
{
/*if there are workers in the ctx that are not able to execute tasks
we consider the ctx empty */
nworkers = _starpu_nworkers_able_to_execute_task(task, sched_ctx);
if (nworkers == 0)
{
STARPU_PTHREAD_MUTEX_LOCK(&sched_ctx->empty_ctx_mutex);
starpu_task_list_push_back(&sched_ctx->empty_ctx_tasks, task);
STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
#ifdef STARPU_USE_SC_HYPERVISOR
if(sched_ctx != NULL && sched_ctx->id != 0 && sched_ctx->perf_counters != NULL
&& sched_ctx->perf_counters->notify_empty_ctx)
{
_STARPU_TRACE_HYPERVISOR_BEGIN();
sched_ctx->perf_counters->notify_empty_ctx(sched_ctx->id, task);
_STARPU_TRACE_HYPERVISOR_END();
}
#endif
return -EAGAIN;
}
}
_starpu_profiling_set_task_push_start_time(task);
int ret = 0;
if (STARPU_UNLIKELY(task->execute_on_a_specific_worker))
{
unsigned node = starpu_worker_get_memory_node(task->workerid);
if (starpu_get_prefetch_flag())
starpu_prefetch_task_input_on_node(task, node);
ret = _starpu_push_task_on_specific_worker(task, task->workerid);
}
else
{
struct _starpu_machine_config *config = _starpu_get_machine_config();
/* When a task can only be executed on a given arch and we have
* only one memory node for that arch, we can systematically
* prefetch before the scheduling decision. */
if (starpu_get_prefetch_flag())
{
if (task->cl->where == STARPU_CPU && config->cpus_nodeid >= 0)
starpu_prefetch_task_input_on_node(task, config->cpus_nodeid);
else if (task->cl->where == STARPU_CUDA && config->cuda_nodeid >= 0)
starpu_prefetch_task_input_on_node(task, config->cuda_nodeid);
else if (task->cl->where == STARPU_OPENCL && config->opencl_nodeid >= 0)
starpu_prefetch_task_input_on_node(task, config->opencl_nodeid);
else if (task->cl->where == STARPU_MIC && config->mic_nodeid >= 0)
starpu_prefetch_task_input_on_node(task, config->mic_nodeid);
else if (task->cl->where == STARPU_SCC && config->scc_nodeid >= 0)
starpu_prefetch_task_input_on_node(task, config->scc_nodeid);
}
if(!sched_ctx->sched_policy)
{
/* Note: we have to call that early, or else the task may have
* disappeared already */
starpu_push_task_end(task);
if(!sched_ctx->awake_workers)
ret = _starpu_push_task_on_specific_worker(task, sched_ctx->main_master);
else
{
struct starpu_worker_collection *workers = sched_ctx->workers;
struct _starpu_job *job = _starpu_get_job_associated_to_task(task);
job->task_size = workers->nworkers;
job->combined_workerid = -1; // workerid; its a ctx not combined worker
job->active_task_alias_count = 0;
STARPU_PTHREAD_BARRIER_INIT(&job->before_work_barrier, NULL, workers->nworkers);
STARPU_PTHREAD_BARRIER_INIT(&job->after_work_barrier, NULL, workers->nworkers);
job->after_work_busy_barrier = workers->nworkers;
unsigned workerid;
struct starpu_sched_ctx_iterator it;
if(workers->init_iterator)
workers->init_iterator(workers, &it);
while(workers->has_next(workers, &it))
{
workerid = workers->get_next(workers, &it);
struct starpu_task *alias = starpu_task_dup(task);
alias->destroy = 1;
ret |= _starpu_push_task_on_specific_worker(alias, workerid);
}
}
}
else
{
STARPU_ASSERT(sched_ctx->sched_policy->push_task);
/* check out if there are any workers in the context */
starpu_pthread_rwlock_t *changing_ctx_mutex = _starpu_sched_ctx_get_changing_ctx_mutex(sched_ctx->id);
STARPU_PTHREAD_RWLOCK_RDLOCK(changing_ctx_mutex);
nworkers = starpu_sched_ctx_get_nworkers(sched_ctx->id);
if (nworkers == 0)
ret = -1;
else
{
_STARPU_TRACE_WORKER_SCHEDULING_PUSH;
ret = sched_ctx->sched_policy->push_task(task);
_STARPU_TRACE_WORKER_SCHEDULING_POP;
}
STARPU_PTHREAD_RWLOCK_UNLOCK(changing_ctx_mutex);
}
if(ret == -1)
{
fprintf(stderr, "repush task \n");
_STARPU_TRACE_JOB_POP(task, task->priority > 0);
ret = _starpu_push_task_to_workers(task);
}
}
/* Note: from here, the task might have been destroyed already! */
_STARPU_LOG_OUT();
return ret;
}
