void socl_init_starpu(void) { starpu_pthread_mutex_lock(&_socl_mutex); if( ! _starpu_init ){ starpu_conf_init(&conf); conf.ncuda = 0; conf.ncpus = 0; _starpu_init_failed = starpu_init(&conf); if (_starpu_init_failed != 0) { DEBUG_MSG("Error when calling starpu_init: %d\n", _starpu_init_failed); } else { if (starpu_opencl_worker_get_count() == 0) { DEBUG_MSG("StarPU didn't find any OpenCL device. Try disabling CUDA support in StarPU (export STARPU_NCUDA=0).\n"); _starpu_init_failed = -ENODEV; } } /* Disable dataflow implicit dependencies */ starpu_data_set_default_sequential_consistency_flag(0); _starpu_init = 1; } starpu_pthread_mutex_unlock(&_socl_mutex); }
static int _starpu_opencl_compile_or_load_opencl_from_file(const char *source_file_name, struct starpu_opencl_program *opencl_programs, const char* build_options) { int nb_devices; char located_file_name[1024]; char located_dir_name[1024]; char new_build_options[1024]; char opencl_program_source[16384]; // Do not try to load and compile the file if there is no devices nb_devices = starpu_opencl_worker_get_count(); if (nb_devices == 0) return EXIT_SUCCESS; starpu_opencl_load_program_source(source_file_name, located_file_name, located_dir_name, opencl_program_source); if (!build_options) build_options = ""; if (!strcmp(located_dir_name, "")) strcpy(new_build_options, build_options); else if (build_options) sprintf(new_build_options, "-I %s %s", located_dir_name, build_options); else sprintf(new_build_options, "-I %s", located_dir_name); _STARPU_DEBUG("Build options: <%s>\n", new_build_options); return _starpu_opencl_compile_or_load_opencl_from_string(opencl_program_source, new_build_options, opencl_programs, source_file_name); }
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 starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs) { unsigned int dev; unsigned int nb_devices; if (!starpu_opencl_worker_get_count()) return 0; nb_devices = _starpu_opencl_get_device_count(); // Iterate over each device for(dev = 0; dev < nb_devices; dev ++) { if (opencl_programs->programs[dev]) { cl_int err; err = clReleaseProgram(opencl_programs->programs[dev]); if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err); } } return 0; }
static int test_cpu(void) { int ret, var = 0; static starpu_pthread_t driver_thread; struct starpu_conf conf; struct starpu_driver d = { .type = STARPU_CPU_WORKER, .id.cpu_id = 0 }; starpu_conf_init(&conf); conf.n_not_launched_drivers = 1; conf.not_launched_drivers = &d; conf.ncpus = 1; ret = starpu_init(&conf); if (ret == -ENODEV || starpu_cpu_worker_get_count() == 0) { FPRINTF(stderr, "WARNING: No CPU worker found\n"); if (ret == 0) starpu_shutdown(); return STARPU_TEST_SKIPPED; } ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d); if (ret != 0) { ret = 1; goto out2; } struct starpu_task *task; task = starpu_task_create(); cl.where = STARPU_CPU; task->cl = &cl; task->cl_arg = &var; task->synchronous = 1; ret = starpu_task_submit(task); if (ret == -ENODEV) { FPRINTF(stderr, "WARNING: No worker can execute this task\n"); ret = STARPU_TEST_SKIPPED; goto out; } FPRINTF(stderr, "[CPU] Var = %d (expected value: 1)\n", var); ret = !!(var != 1); out: starpu_drivers_request_termination(); if (starpu_pthread_join(driver_thread, NULL) != 0) return 1; out2: starpu_shutdown(); return ret; } #endif /* STARPU_USE_CPU */ #ifdef STARPU_USE_CUDA static int test_cuda(void) { int ret, var = 0; static starpu_pthread_t driver_thread; struct starpu_conf conf; struct starpu_driver d = { .type = STARPU_CUDA_WORKER, .id.cuda_id = 0 }; starpu_conf_init(&conf); conf.n_not_launched_drivers = 1; conf.not_launched_drivers = &d; conf.ncuda = 1; ret = starpu_init(&conf); if (ret == -ENODEV || starpu_cuda_worker_get_count() == 0) { FPRINTF(stderr, "WARNING: No CUDA worker found\n"); if (ret == 0) starpu_shutdown(); return STARPU_TEST_SKIPPED; } ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d); if (ret == -1) { ret = 1; goto out; } struct starpu_task *task; task = starpu_task_create(); cl.where = STARPU_CUDA; task->cl = &cl; task->cl_arg = &var; task->synchronous = 1; ret = starpu_task_submit(task); if (ret == -ENODEV) { FPRINTF(stderr, "WARNING: No worker can execute this task\n"); ret = STARPU_TEST_SKIPPED; goto out; } out: starpu_drivers_request_termination(); if (starpu_pthread_join(driver_thread, NULL) != 0) return 1; starpu_shutdown(); FPRINTF(stderr, "[CUDA] Var = %d (expected value: 1)\n", var); ret = !!(var != 1); return ret; } #endif /* STARPU_USE_CUDA */ #ifdef STARPU_USE_OPENCL static int test_opencl(void) { int ret, var = 0; static starpu_pthread_t driver_thread; struct starpu_conf conf; cl_int err; cl_uint pdummy; cl_platform_id platform; err = clGetPlatformIDs(1, &platform, &pdummy); if (err != CL_SUCCESS) { FPRINTF(stderr, "WARNING: No OpenCL platform found\n"); return STARPU_TEST_SKIPPED; } cl_device_type device_type = CL_DEVICE_TYPE_GPU|CL_DEVICE_TYPE_ACCELERATOR; if (starpu_get_env_number("STARPU_OPENCL_ON_CPUS") > 0) device_type |= CL_DEVICE_TYPE_CPU; if (starpu_get_env_number("STARPU_OPENCL_ONLY_ON_CPUS") > 0) device_type = CL_DEVICE_TYPE_CPU; cl_device_id device_id; err = clGetDeviceIDs(platform, device_type, 1, &device_id, NULL); if (err != CL_SUCCESS) { FPRINTF(stderr, "WARNING: No GPU devices found on OpenCL platform\n"); return STARPU_TEST_SKIPPED; } struct starpu_driver d = { .type = STARPU_OPENCL_WORKER, .id.opencl_id = device_id }; starpu_conf_init(&conf); conf.n_not_launched_drivers = 1; conf.not_launched_drivers = &d; conf.ncuda = 0; conf.nopencl = 1; ret = starpu_init(&conf); if (ret == -ENODEV || starpu_opencl_worker_get_count() == 0) { FPRINTF(stderr, "WARNING: No OpenCL workers found\n"); if (ret == 0) starpu_shutdown(); return STARPU_TEST_SKIPPED; } ret = starpu_pthread_create(&driver_thread, NULL, run_driver, &d); if (ret == -1) { ret = 1; goto out; } struct starpu_task *task; task = starpu_task_create(); cl.where = STARPU_OPENCL; task->cl = &cl; task->cl_arg = &var; task->synchronous = 1; ret = starpu_task_submit(task); if (ret == -ENODEV) { FPRINTF(stderr, "WARNING: No worker can execute the task\n"); ret = STARPU_TEST_SKIPPED; goto out; } out: starpu_drivers_request_termination(); if (starpu_pthread_join(driver_thread, NULL) != 0) return 1; starpu_shutdown(); FPRINTF(stderr, "[OpenCL] Var = %d (expected value: 1)\n", var); ret = !!(var != 1); return ret; } #endif /* STARPU_USE_OPENCL */ int main(void) { int ret = STARPU_TEST_SKIPPED; #ifdef STARPU_USE_CPU ret = test_cpu(); if (ret == 1) return 1; #endif #ifdef STARPU_USE_CUDA ret = test_cuda(); if (ret == 1) return 1; #endif #ifdef STARPU_USE_OPENCL ret = test_opencl(); if (ret == 1) return 1; #endif return ret; }