/* the generic interface that call the proper underlying implementation */
int _starpu_push_task(starpu_job_t j, unsigned job_is_already_locked)
{
struct starpu_task *task = j->task;
task->status = STARPU_TASK_READY;
/* in case there is no codelet associated to the task (that's a control
* task), we directly execute its callback and enforce the
* corresponding dependencies */
if (task->cl == NULL)
{
_starpu_handle_job_termination(j, job_is_already_locked);
return 0;
}
if (STARPU_UNLIKELY(task->execute_on_a_specific_worker))
{
unsigned workerid = task->workerid;
struct starpu_worker_s *worker = _starpu_get_worker_struct(workerid);
if (use_prefetch)
{
uint32_t memory_node = starpu_worker_get_memory_node(workerid);
_starpu_prefetch_task_input_on_node(task, memory_node);
}
return _starpu_push_local_task(worker, j);
}
else {
STARPU_ASSERT(policy.push_task);
return policy.push_task(task);
}
}
/* 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;
}
}
/* The scheduling policy may put tasks directly into a worker's local queue so
* that it is not always necessary to create its own queue when the local queue
* is sufficient. If "back" not null, the task is put at the back of the queue
* where the worker will pop tasks first. Setting "back" to 0 therefore ensures
* a FIFO ordering. */
int starpu_push_local_task(int workerid, struct starpu_task *task, int prio)
{
struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
return _starpu_push_local_task(worker, task, prio);
}