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; }