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)
{
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 int submit(struct starpu_codelet *codelet, struct starpu_perfmodel *model)
{
int nloops = 123;
int loop;
starpu_data_handle_t handle;
struct starpu_perfmodel lmodel;
int ret;
int old_nsamples, new_nsamples;
struct starpu_conf conf;
unsigned archid, archtype, devid, ncore;
starpu_conf_init(&conf);
conf.sched_policy_name = "eager";
conf.calibrate = 1;
ret = starpu_init(&conf);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
codelet->model = model;
starpu_vector_data_register(&handle, -1, (uintptr_t)NULL, 100, sizeof(int));
for (loop = 0; loop < nloops; loop++)
{
ret = starpu_task_insert(codelet, STARPU_W, handle, 0);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_data_unregister(handle);
starpu_shutdown();
return EXIT_SUCCESS;
}
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;
}
int
main(void)
{
#ifdef STARPU_USE_CPU
int ret;
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ncpu = starpu_cpu_worker_get_count();
#ifdef STARPU_USE_CUDA
ncuda = starpu_cuda_worker_get_count();
#endif
#ifdef STARPU_USE_OPENCL
nopencl = starpu_opencl_worker_get_count();
#endif
if (ncpu == 0 || !gpus_available())
{
starpu_shutdown();
return 77;
}
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_load_opencl_from_file("examples/basic_examples/multiformat_opencl_kernel.cl",
&opencl_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
ret = starpu_opencl_load_opencl_from_file("examples/basic_examples/multiformat_conversion_codelets_opencl_kernel.cl",
&opencl_conversion_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
init_problem_data();
print_it();
register_data();
create_and_submit_tasks();
unregister_data();
print_it();
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_unload_opencl(&opencl_program);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_unload_opencl");
starpu_opencl_unload_opencl(&opencl_conversion_program);
#endif
starpu_shutdown();
return check_it();
#else
/* Without the CPU, there is no point in using the multiformat
* interface, so this test is pointless. */
return 77;
#endif
}
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);
}
int main(int argc, char **argv)
{
int ret, rank, size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (size%2 != 0)
{
if (rank == 0)
FPRINTF(stderr, "We need a even number of processes.\n");
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
tab = malloc(SIZE*sizeof(float));
starpu_vector_data_register(&tab_handle, STARPU_MAIN_RAM, (uintptr_t)tab, SIZE, sizeof(float));
int nloops = NITER;
int loop;
int other_rank = rank%2 == 0 ? rank+1 : rank-1;
for (loop = 0; loop < nloops; loop++)
{
starpu_tag_t tag = (starpu_tag_t)loop;
if ((loop % 2) == (rank%2))
{
starpu_mpi_isend_detached_unlock_tag(tab_handle, other_rank, loop, MPI_COMM_WORLD, tag);
}
else
{
starpu_mpi_irecv_detached_unlock_tag(tab_handle, other_rank, loop, MPI_COMM_WORLD, tag);
}
starpu_tag_wait(tag);
}
starpu_data_unregister(tab_handle);
free(tab);
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return 0;
}
int main(int argc, char **argv)
{
int ret, rank, size;
starpu_data_handle_t handle;
int var;
MPI_Init(&argc, &argv);
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
if (size<3)
{
FPRINTF(stderr, "We need more than 2 processes.\n");
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
if (rank == 0)
{
int n;
for(n=1 ; n<size ; n++)
{
MPI_Status status;
FPRINTF_MPI(stderr, "receiving from node %d\n", n);
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
starpu_mpi_recv(handle, n, 42, MPI_COMM_WORLD, &status);
starpu_data_acquire(handle, STARPU_R);
STARPU_ASSERT_MSG(var == n, "Received incorrect value <%d> from node <%d>\n", var, n);
FPRINTF_MPI(stderr, "received <%d> from node %d\n", var, n);
starpu_data_release(handle);
starpu_data_unregister(handle);
}
}
else
{
FPRINTF_MPI(stderr, "sending to node %d\n", 0);
var = rank;
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
starpu_mpi_send(handle, 0, 42, MPI_COMM_WORLD);
starpu_data_unregister(handle);
}
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
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;
}
/*main program*/
int main(int argc, char * argv[])
{
/* Init */
int ret;
int mpi_rank, mpi_size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
/*element initialization : domains are connected as a ring for this test*/
int num_elements=NUM_EL;
struct element * el_left=malloc(num_elements*sizeof(el_left[0]));
struct element * el_right=malloc(num_elements*sizeof(el_right[0]));
int i;
for(i=0; i<num_elements; i++)
{
init_element(el_left+i,i+1,((mpi_rank-1)+mpi_size)%mpi_size);
init_element(el_right+i,i+1,(mpi_rank+1)%mpi_size);
}
/* Communication loop */
for (i=0; i<NUM_LOOPS; i++) //number of "computations loops"
{
int e;
for (e=0; e<num_elements; e++) //Do something for each elements
{
insert_work_for_one_element(el_right+e);
insert_work_for_one_element(el_left+e);
}
}
/* End */
starpu_task_wait_for_all();
for(i=0; i<num_elements; i++)
{
free_element(el_left+i);
free_element(el_right+i);
}
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
FPRINTF(stderr, "No assert until end\n");
return 0;
}
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;
}
int main(int argc, char **argv)
{
/* create a simple definite positive symetric matrix example
*
* Hilbert matrix : h(i,j) = 1/(i+j+1)
* */
float ***bmat;
int rank, nodes, ret;
double timing, flops;
int correctness;
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(&argc, &argv, 1);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nodes);
starpu_cublas_init();
parse_args(argc, argv, nodes);
matrix_init(&bmat, rank, nodes, 1);
matrix_display(bmat, rank);
dw_cholesky(bmat, size/nblocks, rank, nodes, &timing, &flops);
starpu_mpi_shutdown();
matrix_display(bmat, rank);
dw_cholesky_check_computation(bmat, rank, nodes, &correctness, &flops);
matrix_free(&bmat, rank, nodes, 1);
starpu_cublas_shutdown();
starpu_shutdown();
assert(correctness);
if (rank == 0)
{
FPRINTF(stdout, "Computation time (in ms): %2.2f\n", timing/1000);
FPRINTF(stdout, "Synthetic GFlops : %2.2f\n", (flops/timing/1000.0f));
}
return 0;
}
int main(int argc, char **argv)
{
int ret=0, global_ret=0;
int rank, size;
MPI_Init(&argc, &argv);
starpu_mpi_comm_rank(MPI_COMM_WORLD, &rank);
starpu_mpi_comm_size(MPI_COMM_WORLD, &size);
ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
ret = starpu_mpi_init(NULL, NULL, 0);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_mpi_init");
if (size%2 != 0)
{
FPRINTF(stderr, "We need a even number of processes.\n");
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return STARPU_TEST_SKIPPED;
}
ret = exchange_variable(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_variable(rank, 1);
if (ret != 0) global_ret = ret;
ret = exchange_void(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_void(rank, 1);
if (ret != 0) global_ret = ret;
ret = exchange_complex(rank, 0);
if (ret != 0) global_ret = ret;
ret = exchange_complex(rank, 1);
if (ret != 0) global_ret = ret;
starpu_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return global_ret;
}
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;
}
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;
}
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");
}
int main(int argc, char **argv)
{
int v=40;
int ret;
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&v, sizeof(int));
double *x = (double*)malloc(sizeof(double));
struct starpu_task *task = starpu_task_create();
task->cl = &cl;
task->prologue_callback_func = callback_func;
task->prologue_callback_arg = NULL;
task->prologue_callback_pop_func = pop_prologue_callback_func;
task->prologue_callback_pop_arg = (void*) 5;
task->handles[0] = handle;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
*x = -999.0;
ret = starpu_task_insert(&cl,
STARPU_RW, handle,
STARPU_PROLOGUE_CALLBACK, prologue_callback_func,
STARPU_PROLOGUE_CALLBACK_ARG, x,
STARPU_PROLOGUE_CALLBACK_POP, pop_prologue_callback_func,
STARPU_PROLOGUE_CALLBACK_POP_ARG, 5,
0);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
starpu_task_wait_for_all();
enodev:
starpu_data_unregister(handle);
free(x);
FPRINTF(stderr, "v -> %d\n", v);
starpu_shutdown();
return (ret == -ENODEV) ? 77 : 0;
}
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");
unsigned b;
for (b = 0; b < NBUFFERS; b++)
{
buffers[b].index = b;
starpu_variable_data_register(&buffers[b].handle, STARPU_MAIN_RAM, (uintptr_t)&buffers[b].val, sizeof(unsigned));
}
unsigned iter;
for (iter = 0; iter < NITER; iter++)
{
for (b = 0; b < NBUFFERS; b++)
{
ret = starpu_data_acquire_cb(buffers[b].handle, STARPU_RW,
callback_sync_data, &buffers[b]);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_data_acquire_cb");
}
}
ret = starpu_task_wait_for_all();
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_wait_for_all");
/* do some cleanup */
ret = EXIT_SUCCESS;
for (b = 0; b < NBUFFERS; b++)
{
starpu_data_unregister(buffers[b].handle);
/* check result */
if (buffers[b].val != NITER)
{
FPRINTF(stderr, "buffer[%u] = %u should be %d\n", b, buffers[b].val, NITER);
ret = EXIT_FAILURE;
}
}
starpu_shutdown();
return ret;
}
static void *
run_driver(void *arg)
{
struct starpu_driver *d = (struct starpu_driver *) arg;
int ret = starpu_driver_run(d);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_driver_run");
return NULL;
}
int
main (int argc, char *argv[])
{
int ret = starpu_omp_init();
STARPU_CHECK_RETURN_VALUE(ret, "starpu_omp_init");
starpu_omp_shutdown();
return 0;
}
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;
}
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");
}
int main(int argc, char **argv)
{
int ret;
#ifdef STARPU_QUICK_CHECK
n /= 10;
k /= 16;
#endif
ret = starpu_initialize(NULL, &argc, &argv);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_load_opencl_from_file("tests/datawizard/sync_and_notify_data_opencl_codelet.cl", &opencl_code, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
starpu_vector_data_register(&v_handle, STARPU_MAIN_RAM, (uintptr_t)v, VECTORSIZE, sizeof(unsigned));
unsigned iter;
for (iter = 0; iter < k; iter++)
{
unsigned ind;
for (ind = 0; ind < n; ind++)
{
/* increment a = v[0] */
struct starpu_codelet cl_inc_a =
{
.cpu_funcs = {cpu_codelet_incA},
#ifdef STARPU_USE_CUDA
.cuda_funcs = {cuda_codelet_incA},
.cuda_flags = {STARPU_CUDA_ASYNC},
#endif
#ifdef STARPU_USE_OPENCL
.opencl_funcs = {opencl_codelet_incA},
.opencl_flags = {STARPU_OPENCL_ASYNC},
int main(int argc, char **argv)
{
int ret;
int var = 42;
starpu_data_handle_t handle;
ret = starpu_init(NULL);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
int copy = starpu_asynchronous_copy_disabled();
FPRINTF(stderr, "copy %d\n", copy);
starpu_variable_data_register(&handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
ret = starpu_task_insert(&cl,
STARPU_R, handle,
0);
if (ret == -ENODEV) goto enodev;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_insert");
starpu_task_wait_for_all();
starpu_data_unregister(handle);
starpu_shutdown();
return 0;
enodev:
starpu_data_unregister(handle);
starpu_shutdown();
/* 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 */
fprintf(stderr, "WARNING: No one can execute this task\n");
return STARPU_TEST_SKIPPED;
}
int main(STARPU_ATTRIBUTE_UNUSED int argc,
STARPU_ATTRIBUTE_UNUSED char **argv)
{
int ret;
if (argc < 2)
{
FPRINTF(stderr, "usage : %s filename [tile size]\n", argv[0]);
exit(-1);
}
if (argc == 3)
{
/* third argument is the tile size */
char *argptr;
r = strtol(argv[2], &argptr, 10);
c = r;
}
inputfile = argv[1];
/* start the runtime */
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
sem_init(&sem, 0, 0U);
init_problem();
launch_spmv_codelets();
sem_wait(&sem);
sem_destroy(&sem);
unregister_data();
print_results();
double totalflop = 2.0*c*r*totaltasks;
double timing = end - start;
FPRINTF(stderr, "Computation took (in ms)\n");
FPRINTF(stdout, "%2.2f\n", timing/1000);
FPRINTF(stderr, "Flop %e\n", totalflop);
FPRINTF(stderr, "GFlops : %2.2f\n", totalflop/timing/1000);
return 0;
}
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;
}
int main(int argc, char **argv)
{
int ret;
struct starpu_conf conf;
starpu_conf_init(&conf);
conf.sched_policy_name = "eager";
conf.calibrate = 2;
ret = starpu_initialize(&conf, &argc, &argv);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_load_opencl_from_file("tests/perfmodels/opencl_memset_kernel.cl",
&opencl_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
int slog;
for (slog = START_LOG; slog < END_LOG; slog++)
{
int size = 1 << slog;
test_memset(size);
}
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_unload_opencl(&opencl_program);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_unload_opencl");
#endif
starpu_shutdown();
return EXIT_SUCCESS;
}
