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;
}
static int initialize_system(float **A, unsigned dim, unsigned pinned)
{
int ret;
#ifdef STARPU_HAVE_MAGMA
magma_init();
#endif
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
#ifdef STARPU_USE_CUDA
initialize_chol_model(&chol_model_11,"chol_model_11",cpu_chol_task_11_cost,cuda_chol_task_11_cost);
initialize_chol_model(&chol_model_21,"chol_model_21",cpu_chol_task_21_cost,cuda_chol_task_21_cost);
initialize_chol_model(&chol_model_22,"chol_model_22",cpu_chol_task_22_cost,cuda_chol_task_22_cost);
#else
initialize_chol_model(&chol_model_11,"chol_model_11",cpu_chol_task_11_cost,NULL);
initialize_chol_model(&chol_model_21,"chol_model_21",cpu_chol_task_21_cost,NULL);
initialize_chol_model(&chol_model_22,"chol_model_22",cpu_chol_task_22_cost,NULL);
#endif
starpu_cublas_init();
#ifndef STARPU_SIMGRID
if (pinned)
{
starpu_malloc((void **)A, (size_t)dim*dim*sizeof(float));
}
else
{
*A = malloc(dim*dim*sizeof(float));
}
#endif
return 0;
}
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)
{
int ret, exit_value = 0;
/* Initialize StarPU */
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/axpy/axpy_opencl_kernel.cl",
&opencl_program, NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_load_opencl_from_file");
#endif
starpu_cublas_init();
/* This is equivalent to
vec_a = malloc(N*sizeof(TYPE));
vec_b = malloc(N*sizeof(TYPE));
*/
starpu_malloc((void **)&_vec_x, N*sizeof(TYPE));
assert(_vec_x);
starpu_malloc((void **)&_vec_y, N*sizeof(TYPE));
assert(_vec_y);
unsigned i;
for (i = 0; i < N; i++)
{
_vec_x[i] = 1.0f; /*(TYPE)starpu_drand48(); */
_vec_y[i] = 4.0f; /*(TYPE)starpu_drand48(); */
}
FPRINTF(stderr, "BEFORE x[0] = %2.2f\n", _vec_x[0]);
FPRINTF(stderr, "BEFORE y[0] = %2.2f\n", _vec_y[0]);
/* Declare the data to StarPU */
starpu_vector_data_register(&_handle_x, STARPU_MAIN_RAM, (uintptr_t)_vec_x, N, sizeof(TYPE));
starpu_vector_data_register(&_handle_y, STARPU_MAIN_RAM, (uintptr_t)_vec_y, N, sizeof(TYPE));
/* Divide the vector into blocks */
struct starpu_data_filter block_filter =
{
.filter_func = starpu_vector_filter_block,
.nchildren = NBLOCKS
};
starpu_data_partition(_handle_x, &block_filter);
starpu_data_partition(_handle_y, &block_filter);
double start;
double end;
start = starpu_timing_now();
unsigned b;
for (b = 0; b < NBLOCKS; b++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &axpy_cl;
task->cl_arg = &_alpha;
task->cl_arg_size = sizeof(_alpha);
task->handles[0] = starpu_data_get_sub_data(_handle_x, 1, b);
task->handles[1] = starpu_data_get_sub_data(_handle_y, 1, b);
task->tag_id = b;
ret = starpu_task_submit(task);
if (ret == -ENODEV)
{
exit_value = 77;
goto enodev;
}
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_task_wait_for_all();
enodev:
starpu_data_unpartition(_handle_x, STARPU_MAIN_RAM);
starpu_data_unpartition(_handle_y, STARPU_MAIN_RAM);
starpu_data_unregister(_handle_x);
starpu_data_unregister(_handle_y);
end = starpu_timing_now();
double timing = end - start;
FPRINTF(stderr, "timing -> %2.2f us %2.2f MB/s\n", timing, 3*N*sizeof(TYPE)/timing);
FPRINTF(stderr, "AFTER y[0] = %2.2f (ALPHA = %2.2f)\n", _vec_y[0], _alpha);
if (exit_value != 77)
exit_value = check();
starpu_free((void *)_vec_x);
starpu_free((void *)_vec_y);
#ifdef STARPU_USE_OPENCL
ret = starpu_opencl_unload_opencl(&opencl_program);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_opencl_unload_opencl");
#endif
/* Stop StarPU */
starpu_shutdown();
return exit_value;
}
int main(int argc, char **argv)
{
int rank;
int world_size;
/*
* Initialization
*/
int thread_support;
if (MPI_Init_thread(&argc, &argv, MPI_THREAD_SERIALIZED, &thread_support) != MPI_SUCCESS) {
fprintf(stderr,"MPI_Init_thread failed\n");
exit(1);
}
if (thread_support == MPI_THREAD_FUNNELED)
fprintf(stderr,"Warning: MPI only has funneled thread support, not serialized, hoping this will work\n");
if (thread_support < MPI_THREAD_FUNNELED)
fprintf(stderr,"Warning: MPI does not have thread support!\n");
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
starpu_srand48((long int)time(NULL));
parse_args(rank, argc, argv);
int ret = starpu_init(NULL);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
/* We disable sequential consistency in this example */
starpu_data_set_default_sequential_consistency_flag(0);
starpu_mpi_init(NULL, NULL, 0);
STARPU_ASSERT(p*q == world_size);
starpu_cublas_init();
int barrier_ret = MPI_Barrier(MPI_COMM_WORLD);
STARPU_ASSERT(barrier_ret == MPI_SUCCESS);
/*
* Problem Init
*/
init_matrix(rank);
fprintf(stderr, "Rank %d: allocated (%d + %d) MB = %d MB\n", rank,
(int)(allocated_memory/(1024*1024)),
(int)(allocated_memory_extra/(1024*1024)),
(int)((allocated_memory+allocated_memory_extra)/(1024*1024)));
display_grid(rank, nblocks);
TYPE *a_r = NULL;
// STARPU_PLU(display_data_content)(a_r, size);
TYPE *x, *y;
if (check)
{
x = calloc(size, sizeof(TYPE));
STARPU_ASSERT(x);
y = calloc(size, sizeof(TYPE));
STARPU_ASSERT(y);
if (rank == 0)
{
unsigned ind;
for (ind = 0; ind < size; ind++)
x[ind] = (TYPE)starpu_drand48();
}
a_r = STARPU_PLU(reconstruct_matrix)(size, nblocks);
if (rank == 0)
STARPU_PLU(display_data_content)(a_r, size);
// STARPU_PLU(compute_ax)(size, x, y, nblocks, rank);
}
barrier_ret = MPI_Barrier(MPI_COMM_WORLD);
STARPU_ASSERT(barrier_ret == MPI_SUCCESS);
double timing = STARPU_PLU(plu_main)(nblocks, rank, world_size);
/*
* Report performance
*/
int reduce_ret;
double min_timing = timing;
double max_timing = timing;
double sum_timing = timing;
reduce_ret = MPI_Reduce(&timing, &min_timing, 1, MPI_DOUBLE, MPI_MIN, 0, MPI_COMM_WORLD);
STARPU_ASSERT(reduce_ret == MPI_SUCCESS);
reduce_ret = MPI_Reduce(&timing, &max_timing, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
STARPU_ASSERT(reduce_ret == MPI_SUCCESS);
reduce_ret = MPI_Reduce(&timing, &sum_timing, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
STARPU_ASSERT(reduce_ret == MPI_SUCCESS);
if (rank == 0)
{
fprintf(stderr, "Computation took: %f ms\n", max_timing/1000);
fprintf(stderr, "\tMIN : %f ms\n", min_timing/1000);
fprintf(stderr, "\tMAX : %f ms\n", max_timing/1000);
fprintf(stderr, "\tAVG : %f ms\n", sum_timing/(world_size*1000));
unsigned n = size;
double flop = (2.0f*n*n*n)/3.0f;
fprintf(stderr, "Synthetic GFlops : %2.2f\n", (flop/max_timing/1000.0f));
}
/*
* Test Result Correctness
*/
if (check)
{
/*
* Compute || A - LU ||
*/
STARPU_PLU(compute_lu_matrix)(size, nblocks, a_r);
#if 0
/*
* Compute || Ax - LUx ||
*/
unsigned ind;
y2 = calloc(size, sizeof(TYPE));
STARPU_ASSERT(y);
if (rank == 0)
{
for (ind = 0; ind < size; ind++)
{
y2[ind] = (TYPE)0.0;
}
}
STARPU_PLU(compute_lux)(size, x, y2, nblocks, rank);
/* Compute y2 = y2 - y */
CPU_AXPY(size, -1.0, y, 1, y2, 1);
TYPE err = CPU_ASUM(size, y2, 1);
int max = CPU_IAMAX(size, y2, 1);
fprintf(stderr, "(A - LU)X Avg error : %e\n", err/(size*size));
fprintf(stderr, "(A - LU)X Max error : %e\n", y2[max]);
#endif
}
/*
* Termination
*/
barrier_ret = MPI_Barrier(MPI_COMM_WORLD);
STARPU_ASSERT(barrier_ret == MPI_SUCCESS);
starpu_cublas_shutdown();
starpu_mpi_shutdown();
starpu_shutdown();
#if 0
MPI_Finalize();
#endif
return 0;
}
int main(int argc, char **argv)
{
double start, end;
int ret;
parse_args(argc, argv);
#ifdef STARPU_QUICK_CHECK
niter /= 10;
#endif
ret = starpu_init(NULL);
if (ret == -ENODEV)
return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
starpu_cublas_init();
init_problem_data();
partition_mult_data();
if (bound)
starpu_bound_start(0, 0);
start = starpu_timing_now();
unsigned x, y, iter;
for (iter = 0; iter < niter; iter++)
{
for (x = 0; x < nslicesx; x++)
for (y = 0; y < nslicesy; y++)
{
struct starpu_task *task = starpu_task_create();
task->cl = &cl;
task->handles[0] = starpu_data_get_sub_data(A_handle, 1, y);
task->handles[1] = starpu_data_get_sub_data(B_handle, 1, x);
task->handles[2] = starpu_data_get_sub_data(C_handle, 2, x, y);
task->flops = 2ULL * (xdim/nslicesx) * (ydim/nslicesy) * zdim;
ret = starpu_task_submit(task);
if (ret == -ENODEV)
{
ret = 77;
goto enodev;
}
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
starpu_task_wait_for_all();
}
end = starpu_timing_now();
if (bound)
starpu_bound_stop();
double timing = end - start;
double min, min_int;
double flops = 2.0*((unsigned long long)niter)*((unsigned long long)xdim)
*((unsigned long long)ydim)*((unsigned long long)zdim);
if (bound)
starpu_bound_compute(&min, &min_int, 1);
PRINTF("# x\ty\tz\tms\tGFlops");
if (bound)
PRINTF("\tTms\tTGFlops\tTims\tTiGFlops");
PRINTF("\n");
PRINTF("%u\t%u\t%u\t%.0f\t%.1f", xdim, ydim, zdim, timing/niter/1000.0, flops/timing/1000.0);
if (bound)
PRINTF("\t%.0f\t%.1f\t%.0f\t%.1f", min, flops/min/1000000.0, min_int, flops/min_int/1000000.0);
PRINTF("\n");
enodev:
starpu_data_unpartition(C_handle, STARPU_MAIN_RAM);
starpu_data_unpartition(B_handle, STARPU_MAIN_RAM);
starpu_data_unpartition(A_handle, STARPU_MAIN_RAM);
starpu_data_unregister(A_handle);
starpu_data_unregister(B_handle);
starpu_data_unregister(C_handle);
if (check)
check_output();
starpu_free(A);
starpu_free(B);
starpu_free(C);
starpu_cublas_shutdown();
starpu_shutdown();
return ret;
}
