/*
* Wait for termination
*/
void wait_end_tasks(int rank)
{
int bz;
int nbz = get_nbz();
for (bz = 0; bz < nbz; bz++)
{
if (get_block_mpi_node(bz) == rank)
{
/* Wait for the task producing block "bz" */
starpu_tag_wait(TAG_FINISH(bz));
/* Get the result back to memory */
struct block_description *block = get_block_description(bz);
starpu_data_acquire(block->layers_handle[0], STARPU_R);
starpu_data_acquire(block->layers_handle[1], STARPU_R);
/* the data_acquire here is done to make sure
* the data is sent back to the ram memory, we
* can safely do a data_release, to avoid the
* data_unregister to block later on
*/
starpu_data_release(block->layers_handle[0]);
starpu_data_release(block->layers_handle[1]);
}
}
}
void wrong_func(void *descr[], void *arg)
{
/* The function is expected to fail. This is indicated in tests/Makefile.am */
/* try to fetch data in the RAM while we are in a codelet, such a
* blocking call is forbidden */
starpu_data_acquire(handle, STARPU_RW);
starpu_tag_wait(TAG);
}
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;
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)
{
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;
}
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");
FPRINTF(stderr, "{ A } -> { B }\n");
fflush(stderr);
struct starpu_task *taskA, *taskB;
taskA = create_dummy_task(tagA);
taskB = create_dummy_task(tagB);
/* B depends on A */
starpu_tag_declare_deps(tagB, 1, tagA);
ret = starpu_task_submit(taskB); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskA); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_tag_wait(tagB); STARPU_CHECK_RETURN_VALUE(ret, "starpu_wait");
FPRINTF(stderr, "{ C, D, E, F } -> { G }\n");
struct starpu_task *taskC, *taskD, *taskE, *taskF, *taskG;
taskC = create_dummy_task(tagC);
taskD = create_dummy_task(tagD);
taskE = create_dummy_task(tagE);
taskF = create_dummy_task(tagF);
taskG = create_dummy_task(tagG);
/* NB: we could have used starpu_tag_declare_deps_array instead */
starpu_tag_declare_deps(tagG, 4, tagC, tagD, tagE, tagF);
ret = starpu_task_submit(taskC); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskD); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskG); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskE); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskF); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_tag_wait(tagG); STARPU_CHECK_RETURN_VALUE(ret, "starpu_tag_wait");
FPRINTF(stderr, "{ H, I } -> { J, K, L }\n");
struct starpu_task *taskH, *taskI, *taskJ, *taskK, *taskL;
taskH = create_dummy_task(tagH);
taskI = create_dummy_task(tagI);
taskJ = create_dummy_task(tagJ);
taskK = create_dummy_task(tagK);
taskL = create_dummy_task(tagL);
starpu_tag_declare_deps(tagJ, 2, tagH, tagI);
starpu_tag_declare_deps(tagK, 2, tagH, tagI);
starpu_tag_declare_deps(tagL, 2, tagH, tagI);
starpu_tag_t tagJKL[3] = {tagJ, tagK, tagL};
ret = starpu_task_submit(taskH); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskI); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskJ); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskK); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_task_submit(taskL); STARPU_CHECK_RETURN_VALUE(ret, "starpu_submit");
ret = starpu_tag_wait_array(3, tagJKL); STARPU_CHECK_RETURN_VALUE(ret, "starpu_tag_wait_array");
starpu_shutdown();
return EXIT_SUCCESS;
}
static void _cholesky(starpu_data_handle_t dataA, unsigned nblocks)
{
double start;
double end;
struct starpu_task *entry_task = NULL;
/* create all the DAG nodes */
unsigned i,j,k;
start = starpu_timing_now();
for (k = 0; k < nblocks; k++)
{
struct starpu_task *task = create_task_11(dataA, k);
/* we defer the launch of the first task */
if (k == 0)
{
entry_task = task;
}
else
{
int ret = starpu_task_submit(task);
if (STARPU_UNLIKELY(ret == -ENODEV))
{
FPRINTF(stderr, "No worker may execute this task\n");
exit(0);
}
}
for (j = k+1; j<nblocks; j++)
{
create_task_21(dataA, k, j);
for (i = k+1; i<nblocks; i++)
{
if (i <= j)
create_task_22(dataA, k, i, j);
}
}
}
/* schedule the codelet */
int ret = starpu_task_submit(entry_task);
if (STARPU_UNLIKELY(ret == -ENODEV))
{
FPRINTF(stderr, "No worker may execute this task\n");
exit(0);
}
/* stall the application until the end of computations */
starpu_tag_wait(TAG11(nblocks-1));
starpu_data_unpartition(dataA, STARPU_MAIN_RAM);
end = starpu_timing_now();
double timing = end - start;
unsigned n = starpu_matrix_get_nx(dataA);
double flop = (1.0f*n*n*n)/3.0f;
PRINTF("# size\tms\tGFlops\n");
PRINTF("%u\t%.0f\t%.1f\n", n, timing/1000, (flop/timing/1000.0f));
}
static int cholesky_grain_rec(float *matA, unsigned size, unsigned ld, unsigned nblocks, unsigned nbigblocks, unsigned reclevel)
{
int ret;
/* create a new codelet */
struct starpu_task *entry_task = NULL;
/* create all the DAG nodes */
unsigned i,j,k;
starpu_data_handle_t dataA;
/* monitor and partition the A matrix into blocks :
* one block is now determined by 2 unsigned (i,j) */
starpu_matrix_data_register(&dataA, STARPU_MAIN_RAM, (uintptr_t)matA, ld, size, size, sizeof(float));
starpu_data_set_sequential_consistency_flag(dataA, 0);
struct starpu_data_filter f =
{
.filter_func = starpu_matrix_filter_vertical_block,
.nchildren = nblocks
};
struct starpu_data_filter f2 =
{
.filter_func = starpu_matrix_filter_block,
.nchildren = nblocks
};
starpu_data_map_filters(dataA, 2, &f, &f2);
for (k = 0; k < nbigblocks; k++)
{
struct starpu_task *task = create_task_11(dataA, k, reclevel);
/* we defer the launch of the first task */
if (k == 0)
{
entry_task = task;
}
else
{
ret = starpu_task_submit(task);
if (ret == -ENODEV) return 77;
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
for (j = k+1; j<nblocks; j++)
{
ret = create_task_21(dataA, k, j, reclevel);
if (ret == -ENODEV) return 77;
for (i = k+1; i<nblocks; i++)
{
if (i <= j)
{
ret = create_task_22(dataA, k, i, j, reclevel);
if (ret == -ENODEV) return 77;
}
}
}
}
/* schedule the codelet */
ret = starpu_task_submit(entry_task);
if (STARPU_UNLIKELY(ret == -ENODEV))
{
FPRINTF(stderr, "No worker may execute this task\n");
return 77;
}
if (nblocks == nbigblocks)
{
/* stall the application until the end of computations */
starpu_tag_wait(TAG11_AUX(nblocks-1, reclevel));
starpu_data_unpartition(dataA, STARPU_MAIN_RAM);
starpu_data_unregister(dataA);
return 0;
}
else
{
STARPU_ASSERT(reclevel == 0);
unsigned ndeps_tags = (nblocks - nbigblocks)*(nblocks - nbigblocks);
starpu_tag_t *tag_array = malloc(ndeps_tags*sizeof(starpu_tag_t));
STARPU_ASSERT(tag_array);
unsigned ind = 0;
for (i = nbigblocks; i < nblocks; i++)
for (j = nbigblocks; j < nblocks; j++)
{
if (i <= j)
tag_array[ind++] = TAG22_AUX(nbigblocks - 1, i, j, reclevel);
}
starpu_tag_wait_array(ind, tag_array);
free(tag_array);
starpu_data_unpartition(dataA, STARPU_MAIN_RAM);
starpu_data_unregister(dataA);
float *newmatA = &matA[nbigblocks*(size/nblocks)*(ld+1)];
return cholesky_grain_rec(newmatA, size/nblocks*(nblocks - nbigblocks), ld, (nblocks - nbigblocks)*2, (nblocks - nbigblocks)*2, reclevel+1);
}
}
static void wrong_callback(void *arg)
{
/* The function is expected to fail. This is indicated in tests/Makefile.am */
starpu_data_acquire(handle, STARPU_RW);
starpu_tag_wait(TAG);
}
