Deferred pipeline multi-thread compilation does not work on my side

[wangchi87]

Hi, I am working on my own ray tracing renderer.

I had a seven ray-clost-hit shader (for better performace, each shader is for different type of material), while add more shaders results in much longer time when "vkCreateRayTracingPipelinesKHR".

The advanced compilation turtorial show a way to reduce the creation time with deferred operation and multi-threading. But it does not work even when I run the tutorial.

I print some information as following ( time and return code)

    auto     x      = std::chrono::steady_clock::now();

    VkResult result = vkDeferredOperationJoinKHR(device, hOp);

    auto     y      = std::chrono::steady_clock::now();

    std::cout << "vkDeferredOperationJoinKHR thread "<< " res" << result << " cost" << std::chrono::duration_cast<std::chrono::milliseconds>(y - x).count()<< " ms" << std::endl;

    assert(result == VK_SUCCESS || result == VK_THREAD_DONE_KHR || result == VK_THREAD_IDLE_KHR);

As result, only ONE thread cost some time with return code VK_SUCCESS, and the rest thread cost 0 ms with return code VK_THREAD_DONE_KHR, which means the deferred operation is not run in multi-threads.

Can any one give me a hint?

PS: I worked on Intel CPU with 3080 RTX Laptop

[mklefrancois]

Hi @wangchi87, please have a second look at the document on "Parallel Compilation Using Deferred Host Operations". This is part of the ray_tracing_advanced_compilation sample. It gives information to speed up the compilation. Basically, I think you're forgetting the fact that shaders need to be distributed across multiple pipelines.

[pgautron]

Hi @wangchi87 the tutorial illustrates two concepts: pipeline libraries and deferred host operations. In that example, instead of building a pipeline directly from shader modules as usual, the modules are first compiled into a pipeline library object. This library is then linked into a finalized pipeline using a deferred operation.
Libraries are very useful when a (set of) shader stage(s) is reused in multiple pipelines. This avoid compiling the modules several times. Deferred operations provide a means for the driver to parallelize the compilation of a given pipeline by providing it with worker threads (the driver cannot create threads on its own). Deferred operations are, however, only a hint to the driver - it may or may not make use of those threads, depending on the task at hand. In this case the finalized pipeline only requires a linking step, which in the current driver runs on a single thread. The other threads then return immediately. It would be possible to use the same deferred operation mechanism when building the pipeline library: each stage would then be compiled in a separate thread. This was not done in the tutorial to keep both concepts separate. We will update it to make this clearer.

[wangchi87]

Hi，@pgautron, Thanks so much for this detailed reply.

I finally found why deferred operation is not actually split into multi-threads on my PC, it seems that the lastest GameReady driver does not support this.....

However, multi-threading began to do the work when I switched to lastest vulkan beta or Studio drivers.

Looking forward to an update of GameReady driver for this, as GameReady offers a better FPS here. :-)