void
_starpu_swap_init(void)
{
char *backend;
char *path;
starpu_ssize_t size;
struct starpu_disk_ops *ops;
int dd;
path = getenv("STARPU_DISK_SWAP");
if (!path)
return;
backend = getenv("STARPU_DISK_SWAP_BACKEND");
if (!backend)
{
_starpu_mkpath(path, S_IRWXU);
ops = &starpu_disk_unistd_ops;
}
else if (!strcmp(backend, "stdio"))
{
_starpu_mkpath(path, S_IRWXU);
ops = &starpu_disk_stdio_ops;
}
else if (!strcmp(backend, "unistd"))
{
_starpu_mkpath(path, S_IRWXU);
ops = &starpu_disk_unistd_ops;
}
else if (!strcmp(backend, "unistd_o_direct"))
{
#ifdef STARPU_LINUX_SYS
_starpu_mkpath(path, S_IRWXU);
ops = &starpu_disk_unistd_o_direct_ops;
#else
_STARPU_DISP("Warning: o_direct support is not compiled in, could not enable disk swap");
return;
#endif
}
else if (!strcmp(backend, "leveldb"))
{
#ifdef STARPU_HAVE_LEVELDB
ops = &starpu_disk_leveldb_ops;
#else
_STARPU_DISP("Warning: leveldb support is not compiled in, could not enable disk swap");
return;
#endif
}
else
{
_STARPU_DISP("Warning: unknown disk swap backend %s, could not enable disk swap", backend);
return;
}
size = starpu_get_env_number_default("STARPU_DISK_SWAP_SIZE", -1);
dd = starpu_disk_register(ops, path, size);
if (dd < 0)
{
_STARPU_DISP("Warning: could not enable disk swap %s on %s with size %ld, could not enable disk swap", backend, path, (long) size);
return;
}
}
int main(int argc, char **argv)
{
int ret;
/* Not supported yet */
if (starpu_get_env_number_default("STARPU_GLOBAL_ARBITER", 0) > 0)
return 77;
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_load_opencl_from_file("examples/reductions/dot_product_opencl_kernels.cl",
&_opencl_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
#ifdef STARPU_USE_CUDA
/* cublasSdot has synchronization issues when using a non-blocking stream */
cublasGetVersion(&cublas_version);
if (cublas_version >= 7050)
starpu_cublas_init();
#endif
unsigned long nelems = _nblocks*_entries_per_block;
size_t size = nelems*sizeof(float);
_x = (float *) malloc(size);
_y = (float *) malloc(size);
_x_handles = (starpu_data_handle_t *) calloc(_nblocks, sizeof(starpu_data_handle_t));
_y_handles = (starpu_data_handle_t *) calloc(_nblocks, sizeof(starpu_data_handle_t));
assert(_x && _y);
starpu_srand48(0);
DOT_TYPE reference_dot = 0.0;
unsigned long i;
for (i = 0; i < nelems; i++)
{
_x[i] = (float)starpu_drand48();
_y[i] = (float)starpu_drand48();
reference_dot += (DOT_TYPE)_x[i]*(DOT_TYPE)_y[i];
}
unsigned block;
for (block = 0; block < _nblocks; block++)
{
starpu_vector_data_register(&_x_handles[block], STARPU_MAIN_RAM,
(uintptr_t)&_x[_entries_per_block*block], _entries_per_block, sizeof(float));
starpu_vector_data_register(&_y_handles[block], STARPU_MAIN_RAM,
(uintptr_t)&_y[_entries_per_block*block], _entries_per_block, sizeof(float));
}
starpu_variable_data_register(&_dot_handle, STARPU_MAIN_RAM, (uintptr_t)&_dot, sizeof(DOT_TYPE));
/*
* Compute dot product with StarPU
*/
starpu_data_set_reduction_methods(_dot_handle, &redux_codelet, &init_codelet);
for (block = 0; block < _nblocks; block++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &dot_codelet;
task->destroy = 1;
task->handles[0] = _x_handles[block];
task->handles[1] = _y_handles[block];
task->handles[2] = _dot_handle;
ret = starpu_task_submit(task);
if (ret == -ENODEV) goto enodev;
STARPU_ASSERT(!ret);
}
for (block = 0; block < _nblocks; block++)
{
starpu_data_unregister(_x_handles[block]);
starpu_data_unregister(_y_handles[block]);
}
starpu_data_unregister(_dot_handle);
FPRINTF(stderr, "Reference : %e vs. %e (Delta %e)\n", reference_dot, _dot, reference_dot - _dot);
#ifdef STARPU_USE_CUDA
if (cublas_version >= 7050)
starpu_cublas_shutdown();
#endif
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_unload_opencl(&_opencl_program);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_unload_opencl");
#endif
starpu_shutdown();
free(_x);
free(_y);
free(_x_handles);
free(_y_handles);
if (fabs(reference_dot - _dot) < reference_dot * 1e-6)
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
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 77;
}
int main(int argc, char **argv)
{
unsigned long i;
int ret;
/* Not supported yet */
if (starpu_get_env_number_default("STARPU_GLOBAL_ARBITER", 0) > 0)
return 77;
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
unsigned long nelems = _nblocks*_entries_per_bock;
size_t size = nelems*sizeof(TYPE);
_x = (TYPE *) malloc(size);
_x_handles = (starpu_data_handle_t *) calloc(_nblocks, sizeof(starpu_data_handle_t));
assert(_x && _x_handles);
/* Initialize the vector with random values */
starpu_srand48(0);
for (i = 0; i < nelems; i++)
_x[i] = (TYPE)starpu_drand48();
unsigned block;
for (block = 0; block < _nblocks; block++)
{
uintptr_t block_start = (uintptr_t)&_x[_entries_per_bock*block];
starpu_vector_data_register(&_x_handles[block], STARPU_MAIN_RAM, block_start,
_entries_per_bock, sizeof(TYPE));
}
/* Initialize current min */
_minmax[0] = TYPE_MAX;
/* Initialize current max */
_minmax[1] = TYPE_MIN;
starpu_variable_data_register(&_minmax_handle, STARPU_MAIN_RAM, (uintptr_t)_minmax, 2*sizeof(TYPE));
/* Set the methods to define neutral elements and to perform the reduction operation */
starpu_data_set_reduction_methods(_minmax_handle, &minmax_redux_codelet, &minmax_init_codelet);
for (block = 0; block < _nblocks; block++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &minmax_codelet;
task->handles[0] = _x_handles[block];
task->handles[1] = _minmax_handle;
ret = starpu_task_submit(task);
if (ret)
{
STARPU_ASSERT(ret == -ENODEV);
FPRINTF(stderr, "This test can only run on CPUs, but there are no CPU workers (this is not a bug).\n");
return 77;
}
}
for (block = 0; block < _nblocks; block++)
{
starpu_data_unregister(_x_handles[block]);
}
starpu_data_unregister(_minmax_handle);
FPRINTF(stderr, "Min : %e\n", _minmax[0]);
FPRINTF(stderr, "Max : %e\n", _minmax[1]);
STARPU_ASSERT(_minmax[0] <= _minmax[1]);
free(_x);
free(_x_handles);
starpu_shutdown();
return 0;
}