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); }