Re: [Starpu-devel] Issues with asynchronous partitioning on temporary data

[Jérôme Richard <jerome.richard@inria.fr>]

Hello,

Ah, no, sorry, it actually is asynchronous.

Fine. But therefore the following code should work, isn't it ?

PS: I forgot to send the previous mail to the mailing list, here is the part of the mail (which contain the code).

2. StarPU reports the following error: The data for the handle
0x2248430 is requested, but the handle does not have a valid value.

That's odd. From your description you seem to be using it right.

I can send a simple example where I encounter the error message.

That's help understand what is going wrong.

The simple following code seems to contain the previous issue.
I tried to remove the calls to the partition_clean but it seems to not solve the issue.

#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <vector>
#include <starpu.h>
#include <cassert>
#include <string>

using namespace std;

const int Nr = 63;
const int Ntheta = 128;
const int Nphi = 32;
const int Nvpar = 15;

void task_compute_preinterp(void* buffers[], void* clArgs)
{
    printf("task_compute_preinterp\n");
}

void task_compute_interp(void* buffers[], void* clArgs)
{
    printf("task_compute_interp\n");
}

void simple()
{
    starpu_codelet codelet_compute_preinterp;
    starpu_codelet_init(&codelet_compute_preinterp);
    codelet_compute_preinterp.where = STARPU_CPU;
    codelet_compute_preinterp.cpu_funcs[0] = task_compute_preinterp;
    codelet_compute_preinterp.nbuffers = 1;
    codelet_compute_preinterp.modes[0] = STARPU_W; // rhs

    starpu_codelet codelet_compute_interp;
    starpu_codelet_init(&codelet_compute_interp);
    codelet_compute_interp.where = STARPU_CPU;
    codelet_compute_interp.cpu_funcs[0] = task_compute_interp;
    codelet_compute_interp.nbuffers = 1;
    codelet_compute_interp.modes[0] = STARPU_RW; // rhs

    starpu_data_filter f1;
    memset(&f1, 0, sizeof(f1));
    f1.filter_func = starpu_matrix_filter_vertical_block;
    f1.nchildren = 1;

    starpu_data_handle_t tmprhs2_f_handles;
    vector<starpu_data_handle_t> tmprhs2_f_handles_children(f1.nchildren);

    starpu_matrix_data_register(&tmprhs2_f_handles, -1, 0, Nr, Nr, Ntheta, sizeof(double));
    starpu_data_partition_plan(tmprhs2_f_handles, &f1, &tmprhs2_f_handles_children[0]);
    starpu_data_partition_submit(tmprhs2_f_handles, f1.nchildren, &tmprhs2_f_handles_children[0]);

printf("parent: %x\n", tmprhs2_f_handles);
for(int blockId=0 ; blockId<f1.nchildren ; ++blockId)
    printf(" - children: %x\n", tmprhs2_f_handles_children[blockId]);

    for(int blockId=0 ; blockId<f1.nchildren ; ++blockId)
    {
        const int srcBlockId = 0;
        const int dstBlockId = blockId;

        starpu_task* task = starpu_task_create();
        task->cl = &codelet_compute_preinterp;
        task->handles[0] = tmprhs2_f_handles_children[dstBlockId];
        int res = starpu_task_submit(task);
        assert(res == 0);
    }

    starpu_data_unpartition_submit(tmprhs2_f_handles, f1.nchildren, &tmprhs2_f_handles_children[0], -1);
    starpu_data_partition_clean(tmprhs2_f_handles, f1.nchildren, &tmprhs2_f_handles_children[0]);

    starpu_task* task = starpu_task_create();
    task->cl = &codelet_compute_interp;
    task->handles[0] = tmprhs2_f_handles;
    int res = starpu_task_submit(task);
    assert(res == 0);

    starpu_data_unregister_submit(tmprhs2_f_handles);

    starpu_task_wait_for_all();
}

int main(int argc, char* argv[])
{
    const int initState = starpu_init(NULL);
    assert(initState == 0);

    simple();

    starpu_shutdown();
    return 0;
}

Jérôme.