Multiple descriptors

[trinhtuanlong]

I have a scene with one compute pipeline to read from an image (render in another process) and process that image and write the result to a different image. I then pass the result to a graphics pipeline to render to the screen. The problem is that the second image is completely ignored by VSG, that I get this error from the debug layer:

Validation Error: [ VUID-vkCmdDispatch-None-08114 ] | MessageID = 0x30b6e267
vkCmdDispatch(): the descriptor [VkDescriptorSet 0x84c0580000000017, Set 0, Binding 1, Index 0, variable "img_output"] is being used in dispatch but has never been updated via vkUpdateDescriptorSets() or a similar call.
The Vulkan spec states: Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT (https://vulkan.lunarg.com/doc/view/1.4.309.0/linux/antora/spec/latest/chapters/dispatch.html#VUID-vkCmdDispatch-None-08114)
Objects: 1
    [0] VkDescriptorSet 0x84c0580000000017

Validation Error: [ VUID-vkCmdDrawIndexed-None-08114 ] | MessageID = 0x3f6fd836
vkCmdDrawIndexed(): the descriptor [VkDescriptorSet 0x2e2cd000000002b, Set 0, Binding 1, Index 0, variable "tex1"] is being used in draw but has never been updated via vkUpdateDescriptorSets() or a similar call.
The Vulkan spec states: Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT (https://vulkan.lunarg.com/doc/view/1.4.309.0/linux/antora/spec/latest/chapters/drawing.html#VUID-vkCmdDrawIndexed-None-08114)
Objects: 1
    [0] VkDescriptorSet 0x2e2cd000000002b

When I switch to write to the first image and render the first image only the output is as expected, so the second descriptorImage must have been ignored somehow. My code is like this:

	auto window = createWindow();
	auto device = initVulkan(window);
	auto options = vsg::Options::create(vsgXchange::all::create());
	vsg::Paths searchPaths;
	searchPaths.push_back(vsg::Path(""));
	auto vkCamera = createCamera(window);
	auto computeShader = loadComputeShaders("shaders/Main.comp", options, searchPaths);
	auto vertexShader = loadVertexShaders("shaders/Main.vert", options, searchPaths);
	auto fragmentShader = loadFragmentShaders("shaders/Main.frag", options, searchPaths);
	auto [drawImage1, data1] = makeDrawImage(vsg::DYNAMIC_DATA_TRANSFER_AFTER_RECORD);
	auto [drawImage2, image2] = makeDrawImage1();
	auto computeImage_in = makeComputeImage(drawImage1);
	auto computeImage_out = makeComputeImage(drawImage2);
	auto graphicsImage = makeGraphicsImage(drawImage1);
	auto graphicsImage1 = makeGraphicsImage(drawImage2);
	auto [bindPipeline, bindDescriptorSet] = buildPipelineAndDescriptorForCompute(device, computeShader, computeImage_in, computeImage_out);
	auto [bindVertexBuffers, bindIndexBuffer] = buildVertexAndIndexBuffers();
	auto pipelineBarrierPreCompute = makePipelineBarrierPreCompute(image2);
	auto computeCommandGraph = buildComputeCommand(pipelineBarrierPreCompute, bindPipeline, bindDescriptorSet, window);
	auto [bindGraphicsPipeline, bindDescriptorSetGraphics] = buildPipelineAndDescriptorForGraphics(device, vertexShader, fragmentShader, graphicsImage, graphicsImage1);
	auto pipelineBarrierPreGraphics = makePipelineBarrierPreGraphics(image2);
	auto graphicsCommandGraph = buildGraphicsCommand(pipelineBarrierPreGraphics, bindGraphicsPipeline, bindDescriptorSetGraphics, bindVertexBuffers, bindIndexBuffer, window, vkCamera);
	auto vkViewer = createViewer(window, vkCamera, {computeCommandGraph,graphicsCommandGraph});

std::tuple<vsg::ref_ptr<vsg::ImageView>, vsg::ref_ptr<vsg::floatArray2D>> makeDrawImage(vsg::DataVariance dataVariance)
{
	auto data = vsg::floatArray2D::create(WIDTH, HEIGHT);
	data->properties.format = VK_FORMAT_R32_SFLOAT;
	data->properties.dataVariance = dataVariance;
	auto image = vsg::Image::create(data);
	image->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	image->usage = VK_IMAGE_USAGE_STORAGE_BIT |  VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
	auto imageView = vsg::ImageView::create(image);
	return std::make_tuple(imageView, data);
}

std::tuple<vsg::ref_ptr<vsg::ImageView>, vsg::ref_ptr<vsg::Image>> makeDrawImage1()
{
	auto image = vsg::Image::create();
	image->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	image->usage = VK_IMAGE_USAGE_STORAGE_BIT |  VK_IMAGE_USAGE_SAMPLED_BIT;
	image->format = VK_FORMAT_R32_SFLOAT;
	image->extent = {WIDTH, HEIGHT, 1};
	image->arrayLayers = 1;
	image->mipLevels = 1;
	auto imageView = vsg::ImageView::create(image);
	return std::make_tuple(imageView, image);
}

vsg::ref_ptr<vsg::DescriptorImage> makeComputeImage(vsg::ref_ptr<vsg::ImageView> imageView)
{
	// auto imageView = vsg::ImageView::create(drawImage);
	auto sampler = vsg::Sampler::create();
	sampler->addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
	sampler->addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
	sampler->addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
	auto imageInfo = vsg::ImageInfo::create(sampler, imageView, VK_IMAGE_LAYOUT_GENERAL);
	auto descriptorImage = vsg::DescriptorImage::create(imageInfo,0,0,VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
	return descriptorImage;
}

vsg::ref_ptr<vsg::DescriptorImage> makeGraphicsImage(vsg::ref_ptr<vsg::ImageView> imageView)
{
	// auto imageView = vsg::ImageView::create(drawImage);
	auto sampler = vsg::Sampler::create();
	auto imageInfo = vsg::ImageInfo::create(sampler, imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
	auto descriptorImage = vsg::DescriptorImage::create(imageInfo,0,0,VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
	return descriptorImage;
}

std::tuple<vsg::ref_ptr<vsg::BindComputePipeline>, vsg::ref_ptr<vsg::BindDescriptorSet>> buildPipelineAndDescriptorForCompute(vsg::ref_ptr<vsg::Device> device, vsg::ref_ptr<vsg::ShaderStage> computeShader, vsg::ref_ptr<vsg::DescriptorImage> inputImage, vsg::ref_ptr<vsg::DescriptorImage> outputImage)
{
	vsg::DescriptorSetLayoutBindings descriptorBindings{{0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}, {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr}};
	auto descriptorSetLayout = vsg::DescriptorSetLayout::create(descriptorBindings);

	auto descriptors = vsg::Descriptors{inputImage, outputImage};
	auto descriptorSet = vsg::DescriptorSet::create(descriptorSetLayout, descriptors);

	auto pipelineLayout = vsg::PipelineLayout::create(vsg::DescriptorSetLayouts{descriptorSetLayout}, vsg::PushConstantRanges{});
	auto bindDescriptorSet = vsg::BindDescriptorSet::create(VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, descriptorSet);

	auto pipeline = vsg::ComputePipeline::create(pipelineLayout, computeShader);
	auto bindPipeline = vsg::BindComputePipeline::create(pipeline);

	return std::make_tuple(bindPipeline, bindDescriptorSet);
}

vsg::ref_ptr<vsg::CommandGraph> buildComputeCommand(vsg::ref_ptr<vsg::PipelineBarrier> pipelineBarrier, vsg::ref_ptr<vsg::BindComputePipeline> bindPipeline, vsg::ref_ptr<vsg::BindDescriptorSet> bindDescriptorSet, vsg::ref_ptr<vsg::Window> window)
{
	auto commandGraph = vsg::CommandGraph::create(window);
	// commandGraph->addChild(pipelineBarrier);
	commandGraph->addChild(bindPipeline);
	commandGraph->addChild(bindDescriptorSet);
	commandGraph->addChild(vsg::Dispatch::create(uint32_t(ceil(float(WIDTH) / float(workgroupSize))), uint32_t(ceil(float(HEIGHT) / float(workgroupSize))), 1));

	return commandGraph;
}

std::tuple<vsg::ref_ptr<vsg::BindGraphicsPipeline>, vsg::ref_ptr<vsg::BindDescriptorSet>> buildPipelineAndDescriptorForGraphics(vsg::ref_ptr<vsg::Device> device, vsg::ref_ptr<vsg::ShaderStage> vertexShader, vsg::ref_ptr<vsg::ShaderStage> fragmentShader, vsg::ref_ptr<vsg::DescriptorImage> drawImage, vsg::ref_ptr<vsg::DescriptorImage> drawImage1)
{
	vsg::PushConstantRanges pushConstantRanges{
		{VK_SHADER_STAGE_VERTEX_BIT, 0, 128}
	};
	vsg::VertexInputState::Bindings vertexBindingsDescriptions{VkVertexInputBindingDescription{0, sizeof(vsg::vec3), VK_VERTEX_INPUT_RATE_VERTEX}, VkVertexInputBindingDescription{1, sizeof(vsg::vec2), VK_VERTEX_INPUT_RATE_VERTEX}};
    vsg::VertexInputState::Attributes vertexAttributeDescriptions{VkVertexInputAttributeDescription{0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}, VkVertexInputAttributeDescription{1, 1, VK_FORMAT_R32G32_SFLOAT, 0}};

	vsg::GraphicsPipelineStates pipelineStates{
		vsg::VertexInputState::create(vertexBindingsDescriptions, vertexAttributeDescriptions),
		vsg::InputAssemblyState::create(),
		vsg::RasterizationState::create(),
		vsg::MultisampleState::create(),
		vsg::ColorBlendState::create(),
		vsg::DepthStencilState::create()
	};

	auto descriptorSetLayoutBindings = vsg::DescriptorSetLayoutBindings{
		{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
		{1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}
	};
	auto descriptorSetLayout = vsg::DescriptorSetLayout::create(descriptorSetLayoutBindings);
	auto descriptors = vsg::Descriptors{drawImage, drawImage1};
	auto descriptorSet = vsg::DescriptorSet::create(descriptorSetLayout, descriptors);
	
	auto pipelineLayout = vsg::PipelineLayout::create(vsg::DescriptorSetLayouts{descriptorSetLayout}, pushConstantRanges);
	auto bindDescriptorSet = vsg::BindDescriptorSet::create(VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, descriptorSet);
	
    auto graphicsPipeline = vsg::GraphicsPipeline::create(pipelineLayout, vsg::ShaderStages{vertexShader, fragmentShader}, pipelineStates);
    auto bindGraphicsPipeline = vsg::BindGraphicsPipeline::create(graphicsPipeline);

	return std::make_tuple(bindGraphicsPipeline, bindDescriptorSet);
}

vsg::ref_ptr<vsg::CommandGraph> buildGraphicsCommand(vsg::ref_ptr<vsg::PipelineBarrier> pipelineBarrier, vsg::ref_ptr<vsg::BindGraphicsPipeline> bindPipeline, vsg::ref_ptr<vsg::BindDescriptorSet> bindDescriptorSet, vsg::ref_ptr<vsg::BindVertexBuffers> bindVertexBuffers, vsg::ref_ptr<vsg::BindIndexBuffer> bindIndexBuffer, vsg::ref_ptr<vsg::Window> window, vsg::ref_ptr<vsg::Camera> camera)
{
	auto commandGraph = vsg::CommandGraph::create(window);
	// commandGraph->addChild(pipelineBarrier);
	auto scene = vsg::StateGroup::create();
	scene->add(bindPipeline);
	auto renderGraph = vsg::createRenderGraphForView(window, camera, scene);
	commandGraph->addChild(renderGraph);
	auto drawCommands = vsg::Commands::create();
	drawCommands->addChild(bindDescriptorSet);
	drawCommands->addChild(bindVertexBuffers);
	drawCommands->addChild(bindIndexBuffer);
	drawCommands->addChild(vsg::DrawIndexed::create(6, 1, 0, 0, 0));
	scene->addChild(drawCommands);
	return commandGraph;
}

vsg::ref_ptr<vsg::Viewer> createViewer(vsg::ref_ptr<vsg::Window> window, vsg::ref_ptr<vsg::Camera> camera, std::vector<vsg::ref_ptr<vsg::CommandGraph>> commandGraph)
{
	auto viewer = vsg::Viewer::create();
	viewer->addWindow(window);
	viewer->assignRecordAndSubmitTaskAndPresentation(commandGraph);
	viewer->compile();
	viewer->addEventHandler(vsg::Trackball::create(camera));
	viewer->addEventHandlers({vsg::CloseHandler::create(viewer)});
	return viewer;
}

[robertosfield]

Unfortunately the github code browser doesn't work well for blocks of code as large as this - the lines are wide enough to be cropped then need a scroll bar, but that only appears if you scroll all the way down to the bottom, but then you loose where you were readying.

If you have the source code in checked into a repo that is publicly available it'd be easier to review the code and spot errors.

[AnyOldName3]

I stuck their code in a gist, which at least adds syntax highlighting and makes it a bit wider, but it still has the problem with the horizontal scrollbar. I thought there used to be a button to enable word wrap, make it even wider or keep the scrollbar visible, but none of those are available, so either they're removed features or I was thinking of GitLab's equivalent feature.

However, it does give you a Raw button, so although it removes syntax highlighting, it does at least fit the screen or show sensible scrollbars if the screen's too small. https://gist.github.com/AnyOldName3/62d67290c07020fd4e63adb31bf7f8a5

[robertosfield]

I haven't yet spotted the error, but a good way of tracking down issues is to enable the API output layer, you can combine this with the vsg::GpuAnnotation instrumentation. The vsgviewer has code that sets up both so have a look at it. This should give you the part of the scene graph and the Vulkan calls that are causing the Vulkan validation error.

[trinhtuanlong]

For what it is worth, here are my compute shader and Fragment shader:

#version 460

layout(constant_id = 0) const int WIDTH = 640;
layout(constant_id = 1) const int HEIGHT = 480;
layout (local_size_x_id = 2, local_size_y_id = 2, local_size_z = 1 ) in;

layout(set = 0, binding = 0, r32f) uniform image2D img_input;
layout(set = 0, binding = 1, r32f) uniform image2D img_output;

void main() {
	ivec2 storePos = ivec2(gl_GlobalInvocationID.xy);
	vec4 pixel = float(0.5).xxxx;
	imageStore(img_output, storePos, pixel);
}

#version 460

layout(location = 0) in vec2 fragTexCoord;

layout(location = 0) out vec4 FragColor;

layout(binding = 0) uniform sampler2D tex;
layout(binding = 1) uniform sampler2D tex1;

void main(void){
	FragColor = texture(tex1, fragTexCoord).rrra;
}

If I switch "img_output" to "img_input" and "tex1" to "tex" there would be no error and the output is as expected.

[robertosfield]

The crash on the report stage is down to the vsg::Profiler::report() method only existing on vsg::Profiler subclass from vsg::Instrumentation, it doesn't exist on the vsg::GpuAnnotation class from vsg::Instrumention. This means if you cast the instrumentation pointer to Profiler, on a GpuAnnoation object, it'll return a nullptr. Just remove the report section of check against nullptr as vsgviewer does.

With GpuAnnotation the annotation is recorded into the vkCommandBuffer as debug utils tokens. The Vulkan API output layer will then write the Vulkan API output to the console. The VSG has support for redirecting std::cout/std::cerr output if required.

[robertosfield]

RenderDoc is worth trying as well - you can run your program within RenderDoc and enable the GpuAnnotation, capture a frame and then step through the frame, you'll see the VSG annotation inserted as well as listing of all the Vulkan calls and associated data.

[trinhtuanlong]

The debug utils throw the same error with nothing else:

ERROR: [Vulkan] vkCmdDispatch(): the descriptor [VkDescriptorSet 0xd10d270000000018, Set 0, Binding 1, Index 0, variable "img_output"] is being used in dispatch but has never been updated via vkUpdateDescriptorSets() or a similar call.
The Vulkan spec states: Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT (https://vulkan.lunarg.com/doc/view/1.4.309.0/linux/antora/spec/latest/chapters/dispatch.html#VUID-vkCmdDispatch-None-08114)
ERROR: [Vulkan] vkCmdDrawIndexed(): the descriptor [VkDescriptorSet 0xb12fb2000000002c, Set 0, Binding 1, Index 0, variable "tex1"] is being used in draw but has never been updated via vkUpdateDescriptorSets() or a similar call.
The Vulkan spec states: Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT (https://vulkan.lunarg.com/doc/view/1.4.309.0/linux/antora/spec/latest/chapters/drawing.html#VUID-vkCmdDrawIndexed-None-08114)

[trinhtuanlong]

I have found a problem with the vkUpdateDescriptorSets call, the binding of two descriptors are the same and the descriptor count is wrong. Do you have any idea why it is so:

Thread 0, Frame 0:
vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) returns void:
    device:                         VkDevice = 0x5a7c7446aa40
    descriptorWriteCount:           uint32_t = 2
    pDescriptorWrites:              const VkWriteDescriptorSet* = 0x5a7c74f26e00
        pDescriptorWrites[0]:           const VkWriteDescriptorSet = 0x5a7c74f26e00:
            sType:                          VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET (35)
            pNext:                          const void* = NULL
            dstSet:                         VkDescriptorSet = 0xd10d270000000018
            dstBinding:                     uint32_t = 0
            dstArrayElement:                uint32_t = 0
            descriptorCount:                uint32_t = 1
            descriptorType:                 VkDescriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE (3)
            pImageInfo:                     const VkDescriptorImageInfo* = 0x5a7c74f26e80
                pImageInfo[0]:                  const VkDescriptorImageInfo = 0x5a7c74f26e80:
                    sampler:                        VkSampler = 0xd5b26f0000000010
                    imageView:                      VkImageView = 0xd175b40000000013
                    imageLayout:                    VkImageLayout = VK_IMAGE_LAYOUT_GENERAL (1)
            pBufferInfo:                    const VkDescriptorBufferInfo* = UNUSED
            pTexelBufferView:               const VkBufferView* = UNUSED
        pDescriptorWrites[1]:           const VkWriteDescriptorSet = 0x5a7c74f26e40:
            sType:                          VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET (35)
            pNext:                          const void* = NULL
            dstSet:                         VkDescriptorSet = 0xd10d270000000018
            dstBinding:                     uint32_t = 0
            dstArrayElement:                uint32_t = 0
            descriptorCount:                uint32_t = 1
            descriptorType:                 VkDescriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE (3)
            pImageInfo:                     const VkDescriptorImageInfo* = 0x5a7c74f26e98
                pImageInfo[0]:                  const VkDescriptorImageInfo = 0x5a7c74f26e98:
                    sampler:                        VkSampler = 0x9fde6b0000000014
                    imageView:                      VkImageView = 0xd897d90000000016
                    imageLayout:                    VkImageLayout = VK_IMAGE_LAYOUT_GENERAL (1)
            pBufferInfo:                    const VkDescriptorBufferInfo* = UNUSED
            pTexelBufferView:               const VkBufferView* = UNUSED
    descriptorCopyCount:            uint32_t = 0
    pDescriptorCopies:              const VkCopyDescriptorSet* = NULL

dstBinding is 0 for both entry and descriptorCount is 1.

[robertosfield]

Ahhh, well spotted, a subtle bug.

Setting the DescriptorImage::dstBinding for each of the two images is probably all that is required to make sure the descriptors get bound in the right place.

[trinhtuanlong]

I did and the output is now as expected. Thank you.

[robertosfield]

Great to hear that you've been able to resolve it.