Update / change "DVZ_VISUAL_IMAGE_CMAP"?

[wolro]

Dear Cyril, dear Datoviz users,

I would like to build an app, where I can use an UI to cycle through a sequence of heatmap plots. So far, displaying a single heatmap (similar as in the "test_vislib_image_cmap()" function) works fine, but trying to change the plot (uploading a different texture) triggers segmentation faults. For small textures (such as 150 * 150 pixels), updating can work many times without crash, but for bigger data (~1500 * 1500 pixels), often the first update causes the segfault, at least on my system.

The code I use for first tests is basically taken from the mentioned test, and consists of two functions (see below), the GUI loop calls the latter ("update_visual") function. The position / texcoords properties are prepared beforehand and not updated with the GUI callback, but putting this in there doesn't seem to change anything.

The segfault is triggered by the line

memcpy(mapped, data, size);

in the "dvz_buffer_upload" function within "vklite.c".

There is a high likelyhood that I misuse the library in some way, and I would be grateful for hints on how to do this correctly.

Note that I did try something similar with the Python wrapper and also ran into crashes.

Thanks, and kind regards!

Wolfgang

`static DvzTexture* build_texture(DvzContext* context, uint32_t S)
{

// Texture.
uvec3 tvec = {S, S, 1};
uvec3 zofs = {0, 0, 0};

DvzTexture* texture = dvz_ctx_texture(context, 2, tvec, VK_FORMAT_R32_SFLOAT);
VkDeviceSize size = S * S * sizeof(float);

float* tex_data = (float*)malloc(size);
double x = 0, y = 0;
uint32_t k = 0;

for (uint32_t i = 0; i < S; i++)
{
    x = -1 + 2 * i / (double)(S - 1);
    for (uint32_t j = 0; j < S; j++)
    {
        y = +1 - 2 * j / (double)(S - 1);
        tex_data[k++] = exp(-2 * (x * x + y * y)) * cos(M_2PI * 3 * x) * sin(M_2PI * 3 * y);
    }
}

dvz_upload_texture(context, texture, zofs, zofs, size, tex_data);
FREE(tex_data)

return texture;

}

void update_visual(DvzCanvas* canvas, DvzVisual* visual) {

    // Texture.
    uint32_t S = (f % 2 == 0) ? f : f + 1;
    float prop_range[] = {-1, +1};


    DvzTexture* texture = build_texture(canvas->gpu->context, S);
    dvz_visual_texture(visual, DVZ_SOURCE_TYPE_IMAGE, 0, texture);
    dvz_visual_data(visual, DVZ_PROP_RANGE, 0, 1, prop_range);

    // We free the memory of the arrays we've created.

    return;

}`

[rossant]

A few suggestions:

• separate the code creating the texture object, and the code generating the texture data. The texture should be created only once.
• allocate the texture data only once (if the size is meant to be fixed during the course of the application). That means calling malloc() at the beginning of the application, and FREE() at the end. When you want to update the texture, just refill the existing buffer and call dvz_visual_data().
• dvz_visual_texture() should be called once
• in other words, the only things that should happen when you want to update the texture are (a) updating the tex_data buffer and (b) calling dvz_upload_texture()

If that still doesn't work, could you post the full script?

[wolro]

Thanks a lot! This makes a lot of sense, I will report back as soon as I have tried these steps.

[wolro]

Worked perfecty! Also found the "dvz_texture_resize" function in case this is needed later.

Thank you for the quick answer!

[wolro]

Hello Cyril,

hopefully I don't have to bug you too often anymore, but the follow-up question concerns basically the last thing I wanted to try for my sandbox app: updates that involve changing the texture size.

I played around with the "dvz_texture_resize()" function + reallocating the tex_data buffer, but doing this with an active texture seems to be a really bad idea :-) Everything involving "dvz_texture_resize()" results either in a "VK_ERROR_DEVICE_LOST" error (validation layer deactivated) or a segfault during "vkQueueSubmit".

Is there some way to change "texture size" on the fly? My next approach would be to tear down and restart the DvzApp upon any update involving a change of the texture size, which would be totally OK for now. But perhaps I am just missing something, as before :-)

In any case, thanks a lot for all your time and effort you are putting into this. This is an amazing library already in this early stage. With surprisingly few real alternatives, at least based on my research.

[rossant]

That's one of the things that should be much more robust in the upcoming version. Could you post your code? Perhaps you could try to "pause" the GPU before and after resizing the texture (dvz_app_wait())? Not sure if that'd do it.

Another approach may be to allocate a large texture (as large as your largest texture) and only allocate part of it depending on your needs, but I don't remember if this branch of the code supports binding part of a texture in a graphics pipeline.

[wolro]

Hi Cyril,

Perhaps you could try to "pause" the GPU before and after resizing the texture (dvz_app_wait())?

I tried this in various combinations, but so far no luck. I didn't get around to try the other approach using a pre-allocated large texture so far, but I can try and report as soon as I have had some time.

That's one of the things that should be much more robust in the upcoming version. Could you post your code?

Understood! It seems that the new version quickly makes progress anyway :-)
I can post the code I used below, but please don't feel obliged to invest time here, as I said it is no big deal and even without resizing there is a lot I can play around with at the moment. I an post the gui callback function that reproduces the crash:

void _gui_callback(DvzCanvas* canvas, DvzEvent ev)`
{
    // unpack user data
    CallbackData cb_data = *static_cast<CallbackData*>(ev.user_data);
    uint32_t S = cb_data.S;
    float* tex_data = cb_data.tex_data;
    DvzTexture* texture = cb_data.dvz_tex;
    DvzApp* app = cb_data.dvz_app;


    dvz_gui_begin("Data generation", DVZ_GUI_FLAGS_NONE);

    ImGui::SliderInt("Number", &f, 5, 10000);
    if (ImGui::Button("Update")) {
        DvzVisual* visual = static_cast<DvzVisual*>(dvz_container_get(&(canvas->scene->visuals), 2)); // probably better to pass the this pointer via user_data

        assert(visual != nullptr && "Visual turned out to be nullptr.");
        assert(f > 0 && "Tried to pass negative or zero image width / height.");

        // get new array size from UI
        S = static_cast<uint32_t>(f); //OK if the slider is limited to positive numbers in uint_16t range
        uvec3 zofs = {0, 0, 0};
        uvec3 tvec = {S, S, 1};
        VkDeviceSize size = S * S * sizeof(float);

        // generate new data array
        float* new_tex_data = (float*)malloc(size);
        generate_data(new_tex_data, S);

        // reallocate texture data array, if S has changed, and copy over data from new array
        tex_data = (float*)realloc(tex_data, size);
        memcpy(tex_data, new_tex_data, size);
        cb_data.tex_data = tex_data;

        // resize texture, if S has changed, and upload
        if ((texture->image->width != S) | (texture->image->height != S)) {
            dvz_texture_resize(texture, tvec);
        }

        dvz_upload_texture(canvas->gpu->context, texture, zofs, zofs, size, tex_data);

        FREE(new_tex_data)
    }
    dvz_gui_end();
}

Doing the same thing in the main function before starting the app works find:

//------------------------ Change resolution and reupload before running the app
uint32_t S_new = 5*S;
uvec3 tvec_new = {S_new, S_new, 1};
VkDeviceSize size_new = S_new * S_new * sizeof(float);

// generate new data array
float* new_tex_data = (float*)malloc(size_new);
generate_data(new_tex_data, S_new);

// resize texture
dvz_texture_resize(texture, tvec_new);

// reallocate texture data array, and copy over data from new array
tex_data = (float*)realloc(tex_data, size_new);
memcpy(tex_data, new_tex_data, size_new);
dvz_upload_texture(canvas->gpu->context, texture, zofs, zofs, size_new, tex_data);`