static
int ws_push_task(struct starpu_task *task)
{
unsigned sched_ctx_id = task->sched_ctx;
struct _starpu_work_stealing_data *ws = (struct _starpu_work_stealing_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
struct _starpu_deque_jobq *deque_queue;
struct _starpu_job *j = _starpu_get_job_associated_to_task(task);
int workerid = starpu_worker_get_id();
unsigned worker = 0;
struct starpu_worker_collection *workers = starpu_sched_ctx_get_worker_collection(sched_ctx_id);
struct starpu_sched_ctx_iterator it;
workers->init_iterator(workers, &it);
/* !! C'est ballot de tout locker! */
while(workers->has_next(workers, &it))
{
worker = workers->get_next(workers, &it);
starpu_pthread_mutex_t *sched_mutex;
starpu_pthread_cond_t *sched_cond;
starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
STARPU_PTHREAD_MUTEX_LOCK(sched_mutex);
}
/* If the current thread is not a worker but
* the main thread (-1), we find the better one to
* put task on its queue */
if (workerid == -1)
workerid = select_worker(sched_ctx_id);
deque_queue = ws->queue_array[workerid];
#ifdef HAVE_AYUDAME_H
if (AYU_event)
{
intptr_t id = workerid;
AYU_event(AYU_ADDTASKTOQUEUE, j->job_id, &id);
}
#endif
_starpu_job_list_push_back(&deque_queue->jobq, j);
deque_queue->njobs++;
starpu_push_task_end(task);
while(workers->has_next(workers, &it))
{
worker = workers->get_next(workers, &it);
starpu_pthread_mutex_t *sched_mutex;
starpu_pthread_cond_t *sched_cond;
starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
#ifndef STARPU_NON_BLOCKING_DRIVERS
STARPU_PTHREAD_COND_SIGNAL(sched_cond);
#endif
STARPU_PTHREAD_MUTEX_UNLOCK(sched_mutex);
}
return 0;
}
static int push_task_dummy(struct starpu_task *task)
{
unsigned sched_ctx_id = task->sched_ctx;
struct dummy_sched_data *data = (struct dummy_sched_data*)starpu_sched_ctx_get_policy_data(sched_ctx_id);
/* NB: In this simplistic strategy, we assume that the context in which
we push task has at least one worker*/
/* lock all workers when pushing tasks on a list where all
of them would pop for tasks */
starpu_pthread_mutex_lock(&data->policy_mutex);
starpu_task_list_push_front(&data->sched_list, task);
starpu_push_task_end(task);
starpu_pthread_mutex_unlock(&data->policy_mutex);
/*if there are no tasks block */
/* wake people waiting for a task */
unsigned worker = 0;
struct starpu_worker_collection *workers = starpu_sched_ctx_get_worker_collection(sched_ctx_id);
struct starpu_sched_ctx_iterator it;
workers->init_iterator(workers, &it);
while(workers->has_next(workers, &it))
{
worker = workers->get_next(workers, &it);
starpu_pthread_mutex_t *sched_mutex;
starpu_pthread_cond_t *sched_cond;
starpu_worker_get_sched_condition(worker, &sched_mutex, &sched_cond);
starpu_pthread_mutex_lock(sched_mutex);
starpu_pthread_cond_signal(sched_cond);
starpu_pthread_mutex_unlock(sched_mutex);
}
return 0;
}
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;
}
/* Enqueue a task into the list of tasks explicitely attached to a worker. In
* case workerid identifies a combined worker, a task will be enqueued into
* each worker of the combination. */
static int _starpu_push_task_on_specific_worker(struct starpu_task *task, int workerid)
{
int nbasic_workers = (int)starpu_worker_get_count();
/* Is this a basic worker or a combined worker ? */
int is_basic_worker = (workerid < nbasic_workers);
unsigned memory_node;
struct _starpu_worker *worker = NULL;
struct _starpu_combined_worker *combined_worker = NULL;
if (is_basic_worker)
{
worker = _starpu_get_worker_struct(workerid);
memory_node = worker->memory_node;
}
else
{
combined_worker = _starpu_get_combined_worker_struct(workerid);
memory_node = combined_worker->memory_node;
}
if (use_prefetch)
starpu_prefetch_task_input_on_node(task, memory_node);
if (is_basic_worker)
_starpu_push_task_on_specific_worker_notify_sched(task, worker, workerid, workerid);
else
{
/* Notify all workers of the combined worker */
int worker_size = combined_worker->worker_size;
int *combined_workerid = combined_worker->combined_workerid;
int j;
for (j = 0; j < worker_size; j++)
{
int subworkerid = combined_workerid[j];
_starpu_push_task_on_specific_worker_notify_sched(task, _starpu_get_worker_struct(subworkerid), subworkerid, workerid);
}
}
#ifdef STARPU_USE_SC_HYPERVISOR
starpu_sched_ctx_call_pushed_task_cb(workerid, task->sched_ctx);
#endif //STARPU_USE_SC_HYPERVISOR
unsigned i;
if (is_basic_worker)
{
unsigned node = starpu_worker_get_memory_node(workerid);
if (_starpu_task_uses_multiformat_handles(task))
{
unsigned nbuffers = STARPU_TASK_GET_NBUFFERS(task);
for (i = 0; i < nbuffers; i++)
{
struct starpu_task *conversion_task;
starpu_data_handle_t handle;
handle = STARPU_TASK_GET_HANDLE(task, i);
if (!_starpu_handle_needs_conversion_task(handle, node))
continue;
conversion_task = _starpu_create_conversion_task(handle, node);
conversion_task->mf_skip = 1;
conversion_task->execute_on_a_specific_worker = 1;
conversion_task->workerid = workerid;
_starpu_task_submit_conversion_task(conversion_task, workerid);
//_STARPU_DEBUG("Pushing a conversion task\n");
}
for (i = 0; i < nbuffers; i++)
{
starpu_data_handle_t handle = STARPU_TASK_GET_HANDLE(task, i);
handle->mf_node = node;
}
}
// if(task->sched_ctx != _starpu_get_initial_sched_ctx()->id)
if(task->priority > 0)
return _starpu_push_local_task(worker, task, 1);
else
return _starpu_push_local_task(worker, task, 0);
}
else
{
/* This is a combined worker so we create task aliases */
int worker_size = combined_worker->worker_size;
int *combined_workerid = combined_worker->combined_workerid;
int ret = 0;
struct _starpu_job *job = _starpu_get_job_associated_to_task(task);
job->task_size = worker_size;
job->combined_workerid = workerid;
job->active_task_alias_count = 0;
STARPU_PTHREAD_BARRIER_INIT(&job->before_work_barrier, NULL, worker_size);
STARPU_PTHREAD_BARRIER_INIT(&job->after_work_barrier, NULL, worker_size);
job->after_work_busy_barrier = worker_size;
/* Note: we have to call that early, or else the task may have
* disappeared already */
starpu_push_task_end(task);
int j;
for (j = 0; j < worker_size; j++)
{
struct starpu_task *alias = starpu_task_dup(task);
alias->destroy = 1;
worker = _starpu_get_worker_struct(combined_workerid[j]);
ret |= _starpu_push_local_task(worker, alias, 0);
}
return ret;
}
}
