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");
}
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 struct starpu_task * create_task_11(starpu_data_handle_t dataA, unsigned k)
{
/* FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */
struct starpu_task *task = create_task(TAG11(k));
task->cl = &cl11;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k);
/* this is an important task */
if (!noprio)
task->priority = STARPU_MAX_PRIO;
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG11(k), 1, TAG22(k-1, k, k));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_SPOTRF(n);
return task;
}
static void create_task_grid(unsigned iter)
{
unsigned i;
FPRINTF(stderr, "init iter %u ni %u...\n", iter, ni);
for (i = 0; i < ni; i++)
{
/* create a new task */
struct starpu_task *task = tasks[iter][i] = starpu_task_create();
task->cl = &cl;
/* task->cl_arg = (void*)(uintptr_t) (i | (iter << 16)); */
task->use_tag = 1;
task->tag_id = TAG(i, iter);
task->detach = 1;
task->destroy = 0;
if (i != 0)
starpu_tag_declare_deps(TAG(i,iter), 1, TAG(i-1,iter));
}
}
static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j,
starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned))
{
// printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i));
struct starpu_task *task = create_task();
task->cl = &cl12;
task->cl_arg = NULL;
/* which sub-data is manipulated ? */
task->buffers[0].handle = get_block(dataAp, nblocks, k, k);
task->buffers[0].mode = STARPU_R;
task->buffers[1].handle = get_block(dataAp, nblocks, j, k);
task->buffers[1].mode = STARPU_RW;
if (!no_prio && (j == k+1)) {
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
#if 0
starpu_tag_declare_deps(TAG12(k, i), 1, PIVOT(k, i));
#endif
if (k > 0) {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
starpu_task_declare_deps_array(task, 1, &EVENT(k,j));
}
else {
starpu_task_declare_deps_array(task, 1, &EVENT(k,k));
}
starpu_task_submit(task, NULL);
}
static void create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j)
{
/* FPRINTF(stdout, "task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22(k,i,j)); */
struct starpu_task *task = create_task(TAG22(k, i, j));
task->cl = &cl22;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, i);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
task->handles[2] = starpu_data_get_sub_data(dataA, 2, i, j);
if (!noprio && (i == k + 1) && (j == k +1) )
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG22(k, i, j), 3, TAG22(k-1, i, j), TAG21(k, i), TAG21(k, j));
}
else
{
starpu_tag_declare_deps(TAG22(k, i, j), 2, TAG21(k, i), TAG21(k, j));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_SGEMM(n, n, n);
int ret = starpu_task_submit(task);
if (STARPU_UNLIKELY(ret == -ENODEV))
{
FPRINTF(stderr, "No worker may execute this task\n");
exit(0);
}
}
static int create_task_22(starpu_data_handle_t dataA, unsigned k, unsigned i, unsigned j, unsigned reclevel)
{
int ret;
/* FPRINTF(stdout, "task 22 k,i,j = %d,%d,%d TAG = %llx\n", k,i,j, TAG22_AUX(k,i,j)); */
struct starpu_task *task = create_task(TAG22_AUX(k, i, j, reclevel));
task->cl = &cl22;
/* which sub-data is manipulated ? */
task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, i);
task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j);
task->handles[2] = starpu_data_get_sub_data(dataA, 2, i, j);
if ( (i == k + 1) && (j == k +1) )
{
task->priority = STARPU_MAX_PRIO;
}
/* enforce dependencies ... */
if (k > 0)
{
starpu_tag_declare_deps(TAG22_AUX(k, i, j, reclevel), 3, TAG22_AUX(k-1, i, j, reclevel), TAG21_AUX(k, i, reclevel), TAG21_AUX(k, j, reclevel));
}
else
{
starpu_tag_declare_deps(TAG22_AUX(k, i, j, reclevel), 2, TAG21_AUX(k, i, reclevel), TAG21_AUX(k, j, reclevel));
}
int n = starpu_matrix_get_nx(task->handles[0]);
task->flops = FLOPS_SGEMM(n, n, n);
ret = starpu_task_submit(task);
if (ret != -ENODEV) STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
return ret;
}
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;
}
void launch_spmv_codelets(void)
{
struct starpu_task *task_tab;
uint8_t *is_entry_tab;
int ret;
/* we call one codelet per block */
unsigned nblocks = starpu_bcsr_get_nnz(sparse_matrix);
unsigned nrows = starpu_bcsr_get_nrow(sparse_matrix);
remainingtasks = NSPMV*nblocks;
totaltasks = remainingtasks;
unsigned taskid = 0;
task_tab = calloc(totaltasks, sizeof(struct starpu_task));
STARPU_ASSERT(task_tab);
is_entry_tab = calloc(totaltasks, sizeof(uint8_t));
STARPU_ASSERT(is_entry_tab);
printf("there will be %d codelets\n", remainingtasks);
uint32_t *rowptr = starpu_bcsr_get_local_rowptr(sparse_matrix);
uint32_t *colind = starpu_bcsr_get_local_colind(sparse_matrix);
start = starpu_timing_now();
unsigned loop;
for (loop = 0; loop < NSPMV; loop++)
{
unsigned row;
unsigned part = 0;
for (row = 0; row < nrows; row++)
{
unsigned index;
if (rowptr[row] == rowptr[row+1])
{
continue;
}
for (index = rowptr[row]; index < rowptr[row+1]; index++, part++)
{
struct starpu_task *task = &task_tab[taskid];
starpu_task_init(task);
task->use_tag = 1;
task->tag_id = taskid;
task->callback_func = init_problem_callback;
task->callback_arg = &remainingtasks;
task->cl = &cl;
task->cl_arg = NULL;
unsigned i = colind[index];
unsigned j = row;
task->handles[0] = starpu_data_get_sub_data(sparse_matrix, 1, part);
task->handles[1] = starpu_data_get_sub_data(vector_in, 1, i);
task->handles[2] = starpu_data_get_sub_data(vector_out, 1, j);
/* all tasks in the same row are dependant so that we don't wait too much for data
* we need to wait on the previous task if we are not the first task of a row */
if (index != rowptr[row & ~0x3])
{
/* this is not the first task in the row */
starpu_tag_declare_deps((starpu_tag_t)taskid, 1, (starpu_tag_t)(taskid-1));
is_entry_tab[taskid] = 0;
}
else
{
/* this is an entry task */
is_entry_tab[taskid] = 1;
}
taskid++;
}
}
}
printf("start submitting tasks !\n");
/* submit ALL tasks now */
unsigned nchains = 0;
unsigned task;
for (task = 0; task < totaltasks; task++)
{
if (is_entry_tab[task])
{
nchains++;
}
ret = starpu_task_submit(&task_tab[task]);
STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
}
printf("end of task submission (there was %d chains for %d tasks : ratio %d tasks per chain) !\n", nchains, totaltasks, totaltasks/nchains);
}
