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
}
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;
}
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;
}
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;
}
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;
}
int
main(int argc, char **argv)
{
data_interface_test_summary *summary;
struct starpu_conf conf;
starpu_conf_init(&conf);
conf.ncuda = 2;
conf.nopencl = 1;
conf.nmic = -1;
if (starpu_initialize(&conf, &argc, &argv) == -ENODEV || starpu_cpu_worker_get_count() == 0)
return STARPU_TEST_SKIPPED;
register_data();
summary = run_tests(&bcsr_config);
if (!summary)
exit(EXIT_FAILURE);
unregister_data();
starpu_shutdown();
data_interface_test_summary_print(stderr, summary);
return data_interface_test_summary_success(summary);
}
void soclShutdown() {
static int shutdown = 0;
if (!shutdown) {
shutdown = 1;
starpu_pthread_mutex_lock(&_socl_mutex);
if( _starpu_init )
starpu_task_wait_for_all();
gc_stop();
if( _starpu_init )
starpu_task_wait_for_all();
int active_entities = gc_active_entity_count();
if (active_entities != 0) {
DEBUG_MSG("Unreleased entities: %d\n", active_entities);
gc_print_remaining_entities();
}
if( _starpu_init && _starpu_init_failed != -ENODEV)
starpu_shutdown();
starpu_pthread_mutex_unlock(&_socl_mutex);
if (socl_devices != NULL) {
free(socl_devices);
socl_devices = NULL;
}
}
}
int main(int argc, char **argv)
{
unsigned i;
double timing;
struct timeval start;
struct timeval end;
parse_args(argc, argv);
starpu_init(NULL);
init_gordon_kernel();
fprintf(stderr, "#tasks : %d\n", ntasks);
gettimeofday(&start, NULL);
for (i = 0; i < ntasks; i++)
{
inject_one_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 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 iter;
double init_timing = 0.0;
double shutdown_timing = 0.0;
for (iter = 0; iter < N; iter++)
{
gettimeofday(&start, NULL);
/* Initialize StarPU */
starpu_init(NULL);
gettimeofday(&end, NULL);
init_timing += (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
gettimeofday(&start, NULL);
/* Shutdown StarPU */
starpu_shutdown();
gettimeofday(&end, NULL);
shutdown_timing += (double)((end.tv_sec - start.tv_sec)*1000000 + (end.tv_usec - start.tv_usec));
}
fprintf(stderr, "starpu_init: %2.2f seconds\n", init_timing/(N*1000000));
fprintf(stderr, "starpu_shutdown: %2.2f seconds\n", shutdown_timing/(N*1000000));
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;
}
int main(int argc, char **argv)
{
int x; float f;
int i, ret;
int ifactor=12;
float ffactor=10.0;
starpu_data_handle_t data_handles[2];
ret = starpu_init(NULL);
if (ret == -ENODEV) return STARPU_TEST_SKIPPED;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
FPRINTF(stderr, "Testing codelet with task_insert and with arguments\n");
ret = test_codelet(&mycodelet_args, 1, 1, 4, 2.0);
if (ret == -ENODEV) goto enodev;
if (ret)
{
FPRINTF(stderr, "Testing codelet with task_insert and without arguments\n");
ret = test_codelet(&mycodelet_noargs, 1, 0, 9, 7.0);
}
if (ret == -ENODEV) goto enodev;
if (ret)
{
FPRINTF(stderr, "Testing codelet with task_build and with arguments\n");
ret = test_codelet(&mycodelet_args, 0, 1, 5, 3.0);
}
if (ret == -ENODEV) goto enodev;
if (ret)
{
FPRINTF(stderr, "Testing codelet with task_build and without arguments\n");
ret = test_codelet(&mycodelet_noargs, 0, 0, 7, 5.0);
}
if (ret == -ENODEV) goto enodev;
starpu_shutdown();
STARPU_RETURN(ret?0:1);
enodev:
starpu_shutdown();
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 STARPU_TEST_SKIPPED;
}
int main() {
starpu_init(NULL);
call();
call();
call();
starpu_shutdown();
}
int main(int argc, char **argv)
{
int ret;
starpu_init(NULL);
starpu_data_malloc_pinned_if_possible((void **)&buffer, VECTORSIZE);
starpu_vector_data_register(&v_handle, 0, (uintptr_t)buffer, VECTORSIZE, sizeof(char));
struct starpu_data_filter f = {
.filter_func = starpu_vector_divide_in_2_filter_func,
/* there are only 2 children */
.nchildren = 2,
/* the length of the first part */
.filter_arg = VECTORSIZE/2,
.get_nchildren = NULL,
.get_child_ops = NULL
};
unsigned iter;
for (iter = 0; iter < NITER; iter++)
{
starpu_data_map_filters(v_handle, 1, &f);
ret = use_handle(starpu_data_get_sub_data(v_handle, 1, 0));
if (ret == -ENODEV)
goto enodev;
ret = use_handle(starpu_data_get_sub_data(v_handle, 1, 1));
if (ret == -ENODEV)
goto enodev;
starpu_task_wait_for_all();
starpu_data_unpartition(v_handle, 0);
ret = use_handle(v_handle);
if (ret == -ENODEV)
goto enodev;
starpu_task_wait_for_all();
}
starpu_data_unregister(v_handle);
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;
}
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)
{
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)
{
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;
}
int main(int argc, char **argv)
{
MPI_Init(NULL, NULL);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
if (size != 2)
{
if (rank == 0)
fprintf(stderr, "We need exactly 2 processes.\n");
MPI_Finalize();
return 0;
}
starpu_init(NULL);
starpu_mpi_initialize();
tab = malloc(SIZE*sizeof(float));
starpu_vector_data_register(&tab_handle, 0, (uintptr_t)tab, SIZE, sizeof(float));
unsigned nloops = NITER;
unsigned loop;
int other_rank = (rank + 1)%2;
for (loop = 0; loop < nloops; loop++)
{
starpu_tag_t tag = (starpu_tag_t)loop;
if ((loop % 2) == rank)
{
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_mpi_shutdown();
starpu_shutdown();
MPI_Finalize();
return 0;
}
/*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 void shutdown_system(float **matA, unsigned pinned)
{
if (pinned)
{
starpu_free(*matA);
}
else
{
free(*matA);
}
starpu_cublas_shutdown();
starpu_shutdown();
}
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(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;
}
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;
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;
}
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)
{
starpu_init(NULL);
int arg = 0x42;
starpu_execute_on_each_worker(func, &arg, STARPU_CPU|STARPU_CUDA|STARPU_OPENCL);
starpu_execute_on_each_worker(func, &arg, STARPU_CPU);
starpu_execute_on_each_worker(func, &arg, STARPU_CUDA);
starpu_execute_on_each_worker(func, &arg, STARPU_OPENCL);
starpu_shutdown();
return 0;
}
