int main(int argc, char **argv)
{
double timing;
struct timeval start;
struct timeval end;
starpu_init(NULL);
fprintf(stderr, "#tasks : %d\n", ntasks);
unsigned i;
for (i = 0; i < ntasks; i++)
{
struct starpu_task *task = starpu_task_create();
/* We check if the function is valid from the codelet or from
* the callback */
task->cl = &dummy_cl;
task->cl_arg = task;
task->callback_func = check_task_callback;
task->callback_arg = task;
int ret = starpu_task_submit(task, NULL);
STARPU_ASSERT(!ret);
}
starpu_task_wait_for_all();
fprintf(stderr, "#empty tasks : %d\n", ntasks);
/* We repeat the same experiment with null codelets */
for (i = 0; i < ntasks; i++)
{
struct starpu_task *task = starpu_task_create();
task->cl = NULL;
/* We check if the function is valid from the callback */
task->callback_func = check_task_callback;
task->callback_arg = task;
int ret = starpu_task_submit(task, NULL);
STARPU_ASSERT(!ret);
}
starpu_task_wait_for_all();
starpu_shutdown();
return 0;
}
int main(int argc, char **argv)
{
int ret;
unsigned loop, nloops=NLOOPS;
ret = starpu_initialize(NULL, &argc, &argv);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
struct starpu_task *taskA, *taskB;
for (loop = 0; loop < nloops; loop++)
{
taskA = create_dummy_task();
taskB = create_dummy_task();
/* By default, dynamically allocated tasks are destroyed at
* termination, we cannot declare a dependency on something
* that does not exist anymore. */
taskA->destroy = 0;
taskA->synchronous = 1;
ret = starpu_task_submit(taskA);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
starpu_task_declare_deps_array(taskB, 1, &taskA);
taskB->synchronous = 1;
ret = starpu_task_submit(taskB);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
starpu_task_destroy(taskA);
}
ret = starpu_task_wait_for_all();
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
starpu_shutdown();
return EXIT_SUCCESS;
enodev:
fprintf(stderr, "WARNING: No one can execute this task\n");
/* yes, we do not perform the computation but we did detect that no one
* could perform the kernel, so this is not an error from StarPU */
starpu_shutdown();
return STARPU_TEST_SKIPPED;
}
static int create_task_grid(unsigned piter)
{
unsigned i, j;
int ret;
/* FPRINTF(stderr, "start iter %d...\n", piter); */
callback_cnt = (ni*nj);
/* create non-entry tasks */
for (j = 0; j < nj; j++)
for (i = 1; i < ni; i++)
{
/* create a new task */
struct starpu_task *task = starpu_task_create();
task->callback_func = callback_cpu;
/* jb->argcb = &coords[i][j]; */
task->cl = &cl;
task->cl_arg = NULL;
task->use_tag = 1;
task->tag_id = TAG(i, j, piter);
/* express deps : (i,j) depends on (i-1, j-1) & (i-1, j+1) */
express_deps(i, j, piter);
ret = starpu_task_submit(task);
if (ret == -ENODEV) return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
/* create entry tasks */
for (j = 0; j < nj; j++)
{
/* create a new task */
struct starpu_task *task = starpu_task_create();
task->callback_func = callback_cpu;
task->cl = &cl;
task->cl_arg = NULL;
task->use_tag = 1;
/* this is an entry task */
task->tag_id = TAG(0, j, piter);
ret = starpu_task_submit(task);
if (ret == -ENODEV) return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
return 0;
}
static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned i)
{
int ret;
/* printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */
struct starpu_task *task = create_task(TAG12(k, i));
task->cl = &cl12;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, i, k);
if (!no_prio && (i == k+1))
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG12(k, i), 2, TAG11(k), TAG22(k-1, i, k));
}
else
{
starpu_tag_declare_deps(TAG12(k, i), 1, TAG11(k));
}
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j)
{
int ret;
struct starpu_task *task = create_task(TAG21(k, j));
task->cl = &cl21;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
if (!no_prio && (j == k+1))
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG21(k, j), 2, TAG11(k), TAG22(k-1, k, j));
}
else
{
starpu_tag_declare_deps(TAG21(k, j), 1, TAG11(k));
}
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
static int create_task_11_pivot(starpu_data_handle_t *dataAp, unsigned nblocks,
unsigned k, struct piv_s *piv_description,
starpu_data_handle_t (* get_block)(starpu_data_handle_t *, unsigned, unsigned, unsigned))
{
int ret;
struct starpu_task *task = starpu_task_create();
task->cl = &cl11_pivot;
task->cl_arg = &piv_description[k];
/* which sub-data is manipulated ? */
task->handles[0] = get_block(dataAp, nblocks, k, k);
task->tag_id = TAG11(k);
/* this is an important task */
if (!no_prio)
task->priority = STARPU_MAX_PRIO;
ret = starpu_task_submit(task);
if (ret != -ENODEV) STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
return ret;
}
int main(int argc, char **argv)
{
int ntasks = NTASKS;
int ret;
struct starpu_conf conf;
starpu_conf_init(&conf);
conf.sched_policy = &dummy_sched_policy,
ret = starpu_init(&conf);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_QUICK_CHECK
ntasks /= 100;
#endif
int i;
for (i = 0; i < ntasks; i++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &dummy_codelet;
task->cl_arg = NULL;
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_task_wait_for_all();
starpu_shutdown();
return 0;
}
int main(int argc, char ** argv) {
starpu_init(NULL);
struct starpu_codelet cl = {
.where = STARPU_CPU,
.cpu_funcs[0] = cpu_func,
.cpu_funcs[1] = NULL,
.nbuffers = 0
};
struct starpu_task* task = starpu_task_create();
// pointer to the codelet
task->cl = &cl;
struct params params = { 1, 2.0f };
task->cl_arg = ¶ms;
task->cl_arg_size = sizeof(params);
task->callback_func = callback_func;
task->callback_arg = (void*) 0x42;
// starpu_task_submit will be a blocking call
task->synchronous = 1;
// submit the task to StarPU
starpu_task_submit(task);
// terminate StarPU
starpu_shutdown();
return 0;
}
static int
create_and_submit_task(unsigned int dev)
{
struct starpu_task *task = starpu_task_create();
switch (dev)
{
#ifdef STARPU_USE_CPU
case STARPU_CPU:
task->cl = &cpu_cl;
break;
#endif
#ifdef STARPU_USE_CUDA
case STARPU_CUDA:
task->cl = &cuda_cl;
break;
#endif
#ifdef STARPU_USE_OPENCL
case STARPU_OPENCL:
task->cl = &opencl_cl;
break;
#endif
default:
assert(0);
}
task->synchronous = 1;
task->handles[0] = array_of_structs_handle;
task->cl_arg = NULL;
task->cl_arg_size = 0;
return starpu_task_submit(task);
}
/* If sequential consistency mode is enabled, this function blocks until the
* handle is available in the requested access mode. */
int _starpu_data_wait_until_available(starpu_data_handle handle, starpu_access_mode mode)
{
/* If sequential consistency is enabled, wait until data is available */
PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
int sequential_consistency = handle->sequential_consistency;
if (sequential_consistency)
{
struct starpu_task *sync_task;
sync_task = starpu_task_create();
sync_task->destroy = 1;
/* It is not really a RW access, but we want to make sure that
* all previous accesses are done */
_starpu_detect_implicit_data_deps_with_handle(sync_task, sync_task, handle, mode);
PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
/* TODO detect if this is superflous */
starpu_event event;
int ret = starpu_task_submit(sync_task, &event);
STARPU_ASSERT(!ret);
starpu_event_wait(event);
starpu_event_release(event);
}
else {
PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
}
return 0;
}
static int create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j, unsigned reclevel)
{
int ret;
struct starpu_task *task = create_task(TAG21_AUX(k, j, reclevel));
task->cl = &cl21;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
if (j == k+1)
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 2, TAG11_AUX(k, reclevel), TAG22_AUX(k-1, k, j, reclevel));
}
else
{
starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 1, TAG11_AUX(k, reclevel));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_STRSM(n, n);
ret = starpu_task_submit(task);
if (ret != -ENODEV) STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
return ret;
}
/* R(z) = R(z+d) = local, just call the save kernel */
static void create_task_save_local(unsigned iter, unsigned z, int dir, int local_rank)
{
struct starpu_task *save_task = starpu_task_create();
struct block_description *descr = get_block_description(z);
save_task->cl = (dir == -1)?&save_cl_bottom:&save_cl_top;
save_task->cl_arg = descr;
/* Saving our border... */
save_task->handles[0] = descr->layers_handle[0];
save_task->handles[1] = descr->layers_handle[1];
/* ... to the neighbour's copy */
struct block_description *neighbour = descr->boundary_blocks[(1+dir)/2];
save_task->handles[2] = neighbour->boundaries_handle[(1-dir)/2][0];
save_task->handles[3] = neighbour->boundaries_handle[(1-dir)/2][1];
/* Bind */
if (iter <= BIND_LAST)
save_task->execute_on_a_specific_worker = get_bind_tasks();
save_task->workerid = descr->preferred_worker;
int ret = starpu_task_submit(save_task);
if (ret)
{
FPRINTF(stderr, "Could not submit task save: %d\n", ret);
STARPU_ABORT();
}
}
int main(int argc, char **argv)
{
int ret;
/* initialize StarPU */
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
struct starpu_task *task = starpu_task_create();
task->cl = &cl; /* Pointer to the codelet defined above */
struct params params = { 1, 2.0f };
task->cl_arg = ¶ms;
task->cl_arg_size = sizeof(params);
task->callback_func = callback_func;
task->callback_arg = (void*) (uintptr_t) 0x42;
/* starpu_task_submit will be a blocking call */
task->synchronous = 1;
/* submit the task to StarPU */
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
/* terminate StarPU */
starpu_shutdown();
return 0;
}
static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j,
starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
{
// printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i));
struct starpu_task *task = create_task();
task->cl = &cl12;
task->cl_arg = NULL;
/* which sub-data is manipulated ? */
task->buffers[0].handle = get_block(dataAp, nblocks, k, k);
task->buffers[0].mode = STARPU_R;
task->buffers[1].handle = get_block(dataAp, nblocks, j, k);
task->buffers[1].mode = STARPU_RW;
if (!no_prio && (j == k+1)) {
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
#if 0
starpu_tag_declare_deps(TAG12(k, i), 1, PIVOT(k, i));
#endif
if (k > 0) {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
starpu_task_declare_deps_array(task, 1, &EVENT(k,j));
}
else {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
}
starpu_task_submit(task, NULL);
}
int main(int argc, char **argv)
{
unsigned i;
double timing;
double start;
double end;
int ret;
parse_args(argc, argv);
#ifdef STARPU_HAVE_VALGRIND_H
if(RUNNING_ON_VALGRIND) ntasks = 5;
#endif
ret = starpu_initialize(NULL, &argc, &argv);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
struct starpu_task task;
starpu_task_init(&task);
task.cl = &dummy_codelet;
task.detach = 0;
FPRINTF(stderr, "#tasks : %u\n", ntasks);
start = starpu_timing_now();
for (i = 0; i < ntasks; i++)
{
ret = starpu_task_submit(&task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
ret = starpu_task_wait(&task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait");
}
end = starpu_timing_now();
timing = end - start;
FPRINTF(stderr, "Total: %f secs\n", timing/1000000);
FPRINTF(stderr, "Per task: %f usecs\n", timing/ntasks);
starpu_task_clean(&task);
starpu_shutdown();
return EXIT_SUCCESS;
enodev:
fprintf(stderr, "WARNING: No one can execute this task\n");
/* yes, we do not perform the computation but we did detect that no one
* could perform the kernel, so this is not an error from StarPU */
starpu_shutdown();
return STARPU_TEST_SKIPPED;
}
static int
run(struct starpu_sched_policy *policy)
{
int ret;
struct starpu_conf conf;
int i;
starpu_conf_init(&conf);
conf.sched_policy = policy;
ret = starpu_init(&conf);
if (ret != 0)
exit(STARPU_TEST_SKIPPED);
starpu_profiling_status_set(1);
struct starpu_codelet clA =
{
.cpu_funcs = {A},
.nbuffers = 0
};
struct starpu_codelet clB =
{
.cpu_funcs = {B},
.nbuffers = 0
};
starpu_srand48(0);
for (i = 0; i < NTASKS; i++)
{
struct starpu_task *task = starpu_task_create();
if (((int)(starpu_drand48()*2))%2)
{
task->cl = &clA;
task->priority=STARPU_MIN_PRIO;
}
else
{
task->cl = &clB;
task->priority=STARPU_MAX_PRIO;
}
task->detach=1;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_task_wait_for_all();
FPRINTF(stdout,"\n");
starpu_shutdown();
return 0;
enodev:
starpu_shutdown();
return -ENODEV;
}
int main(int argc, char **argv)
{
int ret;
ret = starpu_initialize(NULL, &argc, &argv);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
starpu_malloc((void**)&data, sizeof(*data));
*data = 42;
/* register a piece of data */
starpu_vector_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)data,
1, sizeof(unsigned));
struct starpu_task *task = starpu_task_create();
task->cl = &wrong_codelet;
task->handles[0] = handle;
task->use_tag = 1;
task->tag_id = TAG;
task->callback_func = wrong_callback;
task->detach = 0;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
ret = starpu_tag_wait(TAG);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_tag_wait");
/* This call is valid as it is done by the application outside a
* callback */
ret = starpu_data_acquire(handle, STARPU_RW);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_data_acquire");
starpu_data_release(handle);
ret = starpu_task_wait(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait");
starpu_data_unregister(handle);
starpu_free(data);
starpu_shutdown();
return EXIT_SUCCESS;
enodev:
fprintf(stderr, "WARNING: No one can execute this task\n");
/* yes, we do not perform the computation but we did detect that no one
* could perform the kernel, so this is not an error from StarPU */
starpu_shutdown();
return STARPU_TEST_SKIPPED;
}
static
int test_codelet(struct starpu_codelet *codelet, int task_insert, int args, int x, float f)
{
starpu_data_handle_t data_handles[2];
int xx = x;
float ff = f;
int i, ret;
starpu_variable_data_register(&data_handles[0], STARPU_MAIN_RAM, (uintptr_t)&xx, sizeof(xx));
starpu_variable_data_register(&data_handles[1], STARPU_MAIN_RAM, (uintptr_t)&ff, sizeof(ff));
FPRINTF(stderr, "values: %d (%d) %f (%f)\n", xx, _ifactor, ff, _ffactor);
if (task_insert)
{
if (args)
ret = starpu_task_insert(codelet,
STARPU_VALUE, &_ifactor, sizeof(_ifactor),
STARPU_VALUE, &_ffactor, sizeof(_ffactor),
STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
0);
else
ret = starpu_task_insert(codelet,
STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
0);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
}
else
{
struct starpu_task *task;
if (args)
task = starpu_task_build(codelet,
STARPU_VALUE, &_ifactor, sizeof(_ifactor),
STARPU_VALUE, &_ffactor, sizeof(_ffactor),
STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
0);
else
task = starpu_task_build(codelet,
STARPU_RW, data_handles[0], STARPU_RW, data_handles[1],
0);
task->cl_arg_free = 1;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
enodev:
for(i=0 ; i<2 ; i++)
{
starpu_data_unregister(data_handles[i]);
}
FPRINTF(stderr, "values: %d (should be %d) %f (should be %f)\n\n", xx, x*_ifactor, ff, f*_ffactor);
return (ret == -ENODEV ? ret : xx == x*_ifactor && ff == f*_ffactor);
}
void increment_token(void)
{
struct starpu_task *task = starpu_task_create();
task->cl = &increment_cl;
task->handles[0] = token_handle;
int ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
void callback_func(void *callback_arg)
{
int ret;
struct starpu_task *task = starpu_task_create();
task->cl = &cl;
task->handles[0] = handle;
ret = starpu_task_submit(task);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
void inject_one_task(void)
{
struct starpu_task *task = starpu_task_create();
task->cl = &dummy_codelet;
task->cl_arg = NULL;
task->callback_func = NULL;
task->synchronous = 1;
starpu_task_submit(task, NULL);
}
void call() {
struct starpu_task *t = starpu_task_create();
t->cl = &cl;
int param = 1;
t->cl_arg = ¶m;
t->cl_arg_size = sizeof(int);
t->synchronous = 1;
starpu_task_submit(t);
}
int main(int argc, char **argv)
{
starpu_init(NULL);
starpu_data_malloc_pinned_if_possible((void **)&v, VECTORSIZE*sizeof(unsigned));
starpu_vector_data_register(&v_handle, 0, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
unsigned nworker = starpu_worker_get_count();
cnt = nworker*N;
unsigned iter, worker;
for (iter = 0; iter < N; iter++)
{
for (worker = 0; worker < nworker; worker++)
{
/* synchronous prefetch */
unsigned node = starpu_worker_get_memory_node(worker);
starpu_data_prefetch_on_node(v_handle, node, 0);
/* execute a task */
struct starpu_task *task = starpu_task_create();
task->cl = &cl;
task->buffers[0].handle = v_handle;
task->buffers[0].mode = select_random_mode();
task->callback_func = callback;
task->callback_arg = NULL;
task->synchronous = 1;
int ret = starpu_task_submit(task, NULL);
if (ret == -ENODEV)
goto enodev;
}
}
pthread_mutex_lock(&mutex);
if (!finished)
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);
starpu_shutdown();
return 0;
enodev:
fprintf(stderr, "WARNING: No one can execute this task\n");
/* yes, we do not perform the computation but we did detect that no one
* could perform the kernel, so this is not an error from StarPU */
return 0;
}
/* The data must be released by calling starpu_data_release later on */
int starpu_data_acquire_cb(starpu_data_handle handle,
starpu_access_mode mode, void (*callback)(void *), void *arg)
{
STARPU_ASSERT(handle);
struct user_interaction_wrapper *wrapper = malloc(sizeof(struct user_interaction_wrapper));
STARPU_ASSERT(wrapper);
wrapper->handle = handle;
wrapper->mode = mode;
wrapper->callback = callback;
wrapper->callback_arg = arg;
PTHREAD_COND_INIT(&wrapper->cond, NULL);
PTHREAD_MUTEX_INIT(&wrapper->lock, NULL);
wrapper->finished = 0;
//TODO: instead of having the is_prefetch argument, _starpu_fetch_data shoud consider two flags: async and detached
_starpu_spin_lock(&handle->header_lock);
handle->per_node[0].refcnt++;
_starpu_spin_unlock(&handle->header_lock);
PTHREAD_MUTEX_LOCK(&handle->sequential_consistency_mutex);
int sequential_consistency = handle->sequential_consistency;
if (sequential_consistency)
{
wrapper->pre_sync_task = starpu_task_create();
wrapper->pre_sync_task->callback_func = starpu_data_acquire_cb_pre_sync_callback;
wrapper->pre_sync_task->callback_arg = wrapper;
wrapper->post_sync_task = starpu_task_create();
#ifdef STARPU_USE_FXT
starpu_job_t job = _starpu_get_job_associated_to_task(wrapper->pre_sync_task);
job->model_name = "acquire_cb_pre";
job = _starpu_get_job_associated_to_task(wrapper->post_sync_task);
job->model_name = "acquire_cb_post";
#endif
_starpu_detect_implicit_data_deps_with_handle(wrapper->pre_sync_task, wrapper->post_sync_task, handle, mode);
PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
/* TODO detect if this is superflous */
int ret = starpu_task_submit(wrapper->pre_sync_task, NULL);
STARPU_ASSERT(!ret);
}
else {
PTHREAD_MUTEX_UNLOCK(&handle->sequential_consistency_mutex);
starpu_data_acquire_cb_pre_sync_callback(wrapper);
}
return 0;
}
static
int use_handle(starpu_data_handle_t handle)
{
int ret;
struct starpu_task *task;
task = starpu_task_create();
task->cl = &cl;
task->handles[0] = handle;
ret = starpu_task_submit(task);
return ret;
}
int use_handle(starpu_data_handle handle)
{
int ret;
struct starpu_task *task;
task = starpu_task_create();
task->cl = &cl;
task->buffers[0].handle = handle;
task->buffers[0].mode = STARPU_RW;
ret = starpu_task_submit(task, NULL);
return ret;
}
static void launch_codelets(void)
{
#ifdef STARPU_USE_FXT
_starpu_fxt_register_thread(0);
#endif
/* partition the work into slices */
unsigned taskx, tasky;
srand(time(NULL));
/* should we use a single performance model for all archs and use an
* acceleration factor ? */
if (use_common_model) {
cl.model = &sgemm_model_common;
}
else {
cl.model = &sgemm_model;
}
for (taskx = 0; taskx < nslicesx; taskx++)
{
for (tasky = 0; tasky < nslicesy; tasky++)
{
/* A B[task] = C[task] */
struct starpu_task *task = starpu_task_create();
task->cl = &cl;
task->cl_arg = &conf;
task->cl_arg_size = sizeof(struct block_conf);
task->callback_func = callback_func;
task->callback_arg = NULL;
starpu_tag_t tag = TAG(taskx, tasky);
task->use_tag = 1;
task->tag_id = tag;
task->buffers[0].handle = starpu_data_get_sub_data(A_handle, 1, tasky);
task->buffers[0].mode = STARPU_R;
task->buffers[1].handle = starpu_data_get_sub_data(B_handle, 1, taskx);
task->buffers[1].mode = STARPU_R;
task->buffers[2].handle =
starpu_data_get_sub_data(C_handle, 2, taskx, tasky);
task->buffers[2].mode = STARPU_RW;
starpu_task_submit(task, NULL);
}
}
}
int main(int argc, char **argv)
{
double timing;
struct timeval start;
struct timeval end;
parse_args(argc, argv);
starpu_init(NULL);
fprintf(stderr, "#tasks : %d\n", ntasks);
gettimeofday(&start, NULL);
unsigned i;
for (i = 0; i < ntasks; i++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &dummy_codelet;
task->cl_arg = NULL;
task->callback_func = NULL;
task->callback_arg = NULL;
task->destroy = 0;
starpu_event event;
int ret = starpu_task_submit(task, &event);
STARPU_ASSERT(!ret);
ret = starpu_event_wait(event);
STARPU_ASSERT(!ret);
starpu_event_release(event);
starpu_task_destroy(task);
}
gettimeofday(&end, NULL);
timing = (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
fprintf(stderr, "Total: %lf secs\n", timing/1000000);
fprintf(stderr, "Per task: %lf usecs\n", timing/ntasks);
starpu_shutdown();
return 0;
}
static
int inject_one_task(void)
{
int ret;
struct starpu_task *task = starpu_task_create();
task->cl = &dummy_codelet;
task->cl_arg = NULL;
task->callback_func = NULL;
task->synchronous = 1;
ret = starpu_task_submit(task);
return ret;
}
static int start_task_grid(unsigned iter)
{
unsigned i;
int ret;
/* FPRINTF(stderr, "start grid %d ni %d...\n", iter, ni); */
for (i = 0; i < ni; i++)
{
ret = starpu_task_submit(tasks[iter][i]);
if (ret == -ENODEV) return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
return 0;
}