Attachment 137738 Details for Bug 105320 – Sample program

Sample program

spv-atomic-decrement.c (text/x-csrc), 27.79 KB, created by Józef Kucia on 2018-03-01 23:12:51 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Józef Kucia

Created: 2018-03-01 23:12:51 UTC

Size: 27.79 KB

patch

obsolete

>/*
> * gcc -lvulkan spv-atomic-decrement.c -o spv-atomic-decrement
> */
>#include <assert.h>
>#include <stdbool.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>
>#define VK_USE_PLATFORM_XCB_KHR
>
>#include <vulkan/vulkan.h>
>
>#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
>
>static const char * const instance_extensions[] =
>{
>    VK_KHR_SURFACE_EXTENSION_NAME,
>    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
>};
>
>static const char * const device_extensions[] =
>{
>    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
>};
>
>static VkInstance create_instance(void)
>{
>    VkApplicationInfo application_info;
>    VkInstanceCreateInfo instance_info;
>    VkInstance instance;
>    VkResult vr;
>
>    application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
>    application_info.pNext = NULL;
>    application_info.pApplicationName = "vk-dump-shader";
>    application_info.applicationVersion = 0;
>    application_info.pEngineName = NULL;
>    application_info.engineVersion = 0;
>    application_info.apiVersion = VK_API_VERSION_1_0;
>
>    instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
>    instance_info.pNext = NULL;
>    instance_info.flags = 0;
>    instance_info.pApplicationInfo = &application_info;
>    instance_info.enabledLayerCount = 0;
>    instance_info.ppEnabledLayerNames = NULL;
>    instance_info.enabledExtensionCount = ARRAY_SIZE(instance_extensions);
>    instance_info.ppEnabledExtensionNames = instance_extensions;
>
>    if ((vr = vkCreateInstance(&instance_info, NULL, &instance)))
>    {
>        fprintf(stderr, "Failed to create Vulkan instance, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return instance;
>}
>
>static VkPhysicalDevice select_physical_device(VkInstance instance)
>{
>    VkPhysicalDevice *physical_devices, selected_device;
>    uint32_t count;
>    unsigned int i;
>    VkResult vr;
>
>    count = 0;
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, NULL)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    if (!count)
>    {
>        fprintf(stderr, "No physical device available.\n");
>        return VK_NULL_HANDLE;
>    }
>    if (!(physical_devices = calloc(count, sizeof(*physical_devices))))
>        return VK_NULL_HANDLE;
>
>    if ((vr = vkEnumeratePhysicalDevices(instance, &count, physical_devices)) < 0)
>    {
>        fprintf(stderr, "Failed to enumerate physical devices, vr %d.\n", vr);
>        free(physical_devices);
>        return VK_NULL_HANDLE;
>    }
>
>    selected_device = physical_devices[0];
>    free(physical_devices);
>    return selected_device;
>}
>
>static VkDevice create_device(VkInstance instance, VkPhysicalDevice physical_device)
>{
>    VkQueueFamilyProperties *queue_properties;
>    VkPhysicalDeviceFeatures device_features;
>    VkDeviceQueueCreateInfo *queue_info;
>    VkDeviceCreateInfo device_info;
>    uint32_t queue_family_count;
>    VkDevice device;
>    unsigned int i;
>    VkResult vr;
>
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, NULL);
>    if (!(queue_properties = calloc(queue_family_count, sizeof(*queue_properties))))
>        return VK_NULL_HANDLE;
>    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_properties);
>
>    if (!(queue_info = calloc(queue_family_count, sizeof(*queue_info))))
>    {
>        free(queue_properties);
>        return VK_NULL_HANDLE;
>    }
>
>    for (i = 0; i < queue_family_count; ++i)
>    {
>        static float priorities[] = {1.0f};
>
>        queue_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
>        queue_info[i].pNext = NULL;
>        queue_info[i].flags = 0;
>        queue_info[i].queueFamilyIndex = i;
>        queue_info[i].queueCount = 1;
>        queue_info[i].pQueuePriorities = priorities;
>    }
>    free(queue_properties);
>
>    vkGetPhysicalDeviceFeatures(physical_device, &device_features);
>
>    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
>    device_info.pNext = NULL;
>    device_info.flags = 0;
>    device_info.queueCreateInfoCount = queue_family_count;
>    device_info.pQueueCreateInfos = queue_info;
>    device_info.enabledLayerCount = 0;
>    device_info.ppEnabledLayerNames = NULL;
>    device_info.enabledExtensionCount = ARRAY_SIZE(device_extensions);
>    device_info.ppEnabledExtensionNames = device_extensions;
>    device_info.pEnabledFeatures = &device_features;
>
>    vr = vkCreateDevice(physical_device, &device_info, NULL, &device);
>    free(queue_info);
>    if (vr < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan device, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return device;
>}
>
>static VkShaderModule create_shader_module(VkDevice device, size_t size, const void *code)
>{
>    VkShaderModuleCreateInfo create_info;
>    VkShaderModule module;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
>    create_info.codeSize = size;
>    create_info.pCode = code;
>    if ((vr = vkCreateShaderModule(device, &create_info, NULL, &module)) < 0)
>    {
>        fprintf(stderr, "Failed to create shader module, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return module;
>}
>
>static void init_shader_stage(VkPipelineShaderStageCreateInfo *stage_desc,
>        VkShaderStageFlagBits stage, VkShaderModule shader_module)
>{
>    stage_desc->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
>    stage_desc->pNext = NULL;
>    stage_desc->flags = 0;
>    stage_desc->stage = stage;
>    stage_desc->module = shader_module;
>    stage_desc->pName = "main";
>    stage_desc->pSpecializationInfo = NULL;
>}
>
>static VkPipeline create_compute_pipeline(VkDevice device,
>        VkPipelineLayout layout, VkShaderModule cs)
>{
>    VkComputePipelineCreateInfo pipeline_info;
>    VkPipelineLayout pipeline_layout;
>    VkPipeline pipeline;
>    VkResult vr;
>
>    pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
>    pipeline_info.pNext = NULL;
>    pipeline_info.flags = 0;
>    init_shader_stage(&pipeline_info.stage, VK_SHADER_STAGE_COMPUTE_BIT, cs);
>    pipeline_info.layout = layout;
>    pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
>    pipeline_info.basePipelineIndex = -1;
>    if ((vr = vkCreateComputePipelines(device, VK_NULL_HANDLE,
>            1, &pipeline_info, NULL, &pipeline)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pipeline;
>}
>
>static VkDescriptorSetLayout create_descriptor_set_layout(VkDevice device)
>{
>    VkDescriptorSetLayoutCreateInfo create_info;
>    VkDescriptorSetLayoutBinding bindings[2];
>    VkDescriptorSetLayout layout;
>    unsigned int i;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.bindingCount = ARRAY_SIZE(bindings);
>    create_info.pBindings = bindings;
>
>    for (i = 0; i < ARRAY_SIZE(bindings); ++i)
>    {
>        bindings[i].binding = i;
>        bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
>        bindings[i].descriptorCount = 1;
>        bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
>        bindings[i].pImmutableSamplers = NULL;
>    }
>
>    if ((vr = vkCreateDescriptorSetLayout(device, &create_info, NULL, &layout) < 0))
>    {
>        fprintf(stderr, "Failed to create descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkDescriptorPool create_descriptor_pool(VkDevice device)
>{
>    VkDescriptorPoolCreateInfo create_info;
>    VkDescriptorPoolSize pool_sizes[1];
>    VkDescriptorPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.maxSets = 32;
>    create_info.poolSizeCount = ARRAY_SIZE(pool_sizes);
>    create_info.pPoolSizes = pool_sizes;
>
>    pool_sizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
>    pool_sizes[0].descriptorCount = 32;
>
>    if ((vr = vkCreateDescriptorPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create descriptor pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkDescriptorSet allocate_descriptor_set(VkDevice device,
>        VkDescriptorPool pool, VkDescriptorSetLayout set_layout)
>{
>    VkDescriptorSetAllocateInfo allocate_info;
>    VkDescriptorSet set;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.descriptorPool = pool;
>    allocate_info.descriptorSetCount = 1;
>    allocate_info.pSetLayouts = &set_layout;
>
>    if ((vr = vkAllocateDescriptorSets(device, &allocate_info, &set)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return set;
>}
>
>static VkPipelineLayout create_pipeline_layout(VkDevice device,
>        VkDescriptorSetLayout set_layout)
>{
>    VkPipelineLayoutCreateInfo create_info;
>    VkPipelineLayout layout;
>    VkResult vr;
>
>    memset(&create_info, 0, sizeof(create_info));
>    create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
>    if (set_layout)
>    {
>        create_info.setLayoutCount = 1;
>        create_info.pSetLayouts = &set_layout;
>    }
>
>    if ((vr = vkCreatePipelineLayout(device, &create_info, NULL, &layout)) < 0)
>    {
>        fprintf(stderr, "Failed to create pipeline layout, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return layout;
>}
>
>static VkCommandPool create_command_pool(VkDevice device, uint32_t queue_index)
>{
>    VkCommandPoolCreateInfo create_info;
>    VkCommandPool pool;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.queueFamilyIndex = queue_index;
>
>    if ((vr = vkCreateCommandPool(device, &create_info, NULL, &pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create command pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return pool;
>}
>
>static VkCommandBuffer allocate_command_buffer(VkDevice device, VkCommandPool pool)
>{
>    VkCommandBufferAllocateInfo allocate_info;
>    VkCommandBuffer command_buffer;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.commandPool = pool;
>    allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
>    allocate_info.commandBufferCount = 1;
>
>    if ((vr = vkAllocateCommandBuffers(device, &allocate_info, &command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate command buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return command_buffer;
>}
>
>static void begin_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkCommandBufferBeginInfo begin_info;
>    VkResult vr;
>
>    begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
>    begin_info.pNext = NULL;
>    begin_info.flags = 0;
>    begin_info.pInheritanceInfo = NULL;
>
>    if ((vr = vkBeginCommandBuffer(command_buffer, &begin_info)) < 0)
>    {
>        fprintf(stderr, "Failed to begin command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void end_command_buffer(VkCommandBuffer command_buffer)
>{
>    VkResult vr;
>
>    if ((vr = vkEndCommandBuffer(command_buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to end command buffer, vr %d.\n", vr);
>    }
>    assert(vr == VK_SUCCESS);
>}
>
>static void submit_commands(VkDevice device,
>        VkQueue queue, VkCommandBuffer command_buffer, bool wait)
>{
>    VkFenceCreateInfo create_info;
>    VkSubmitInfo submit_info;
>    VkFence fence;
>    VkResult vr;
>
>    fence = VK_NULL_HANDLE;
>    if (wait)
>    {
>        create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
>        create_info.pNext = NULL;
>        create_info.flags = 0;
>
>        if ((vr = vkCreateFence(device, &create_info, NULL, &fence)) < 0)
>        {
>            fprintf(stderr, "Failed to create fence, vr %d.\n", vr);
>            return;
>        }
>    }
>
>    memset(&submit_info, 0, sizeof(submit_info));
>    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
>    submit_info.pNext = NULL;
>    submit_info.commandBufferCount = 1;
>    submit_info.pCommandBuffers = &command_buffer;
>
>    if ((vr = vkQueueSubmit(queue, 1, &submit_info, fence) < 0))
>    {
>        fprintf(stderr, "Failed to submit commands, vr %d.\n", vr);
>        vkDestroyFence(device, fence, NULL);
>        return;
>    }
>
>    if ((vr = vkWaitForFences(device, 1, &fence, VK_FALSE, ~0u)) < 0)
>    {
>        fprintf(stderr, "Failed to wait for fences, vr %d.\n", vr);
>        return;
>    }
>
>    vkDestroyFence(device, fence, NULL);
>}
>
>static VkBuffer create_buffer(VkDevice device,
>        VkDeviceSize size, VkBufferUsageFlags usage)
>{
>    VkBufferCreateInfo buffer_info;
>    VkBuffer buffer;
>    VkResult vr;
>
>    buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
>    buffer_info.pNext = NULL;
>    buffer_info.flags = 0;
>    buffer_info.size = size;
>    buffer_info.usage = usage;
>    buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
>    buffer_info.queueFamilyIndexCount = 0;
>    buffer_info.pQueueFamilyIndices = 0;
>
>    if ((vr = vkCreateBuffer(device, &buffer_info, NULL, &buffer)) < 0)
>    {
>        fprintf(stderr, "Failed to create Vulkan buffer, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer;
>}
>
>static unsigned int select_memory_type(VkDevice device, VkPhysicalDevice physical_device,
>        uint32_t memory_type_mask, VkMemoryPropertyFlags required_flags)
>{
>    VkPhysicalDeviceMemoryProperties memory_info;
>    unsigned int i;
>
>    vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_info);
>
>    for (i = 0; i < memory_info.memoryTypeCount; ++i)
>    {
>        if (!(memory_type_mask & (1u << i)))
>            continue;
>        if ((memory_info.memoryTypes[i].propertyFlags & required_flags) == required_flags)
>            return i;
>    }
>
>    return ~0u;
>}
>
>static VkDeviceMemory allocate_device_memory(VkDevice device, VkPhysicalDevice physical_device,
>        const VkMemoryRequirements *memory_requirements, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryAllocateInfo allocate_info;
>    VkDeviceMemory vk_memory;
>    VkResult vr;
>
>    allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
>    allocate_info.pNext = NULL;
>    allocate_info.allocationSize = memory_requirements->size;
>    allocate_info.memoryTypeIndex = select_memory_type(device, physical_device,
>            memory_requirements->memoryTypeBits, memory_flags);
>
>    if (allocate_info.memoryTypeIndex == ~0u)
>    {
>        fprintf(stderr, "Failed to find suitable memory type (allowed types %#x).\n",
>                memory_requirements->memoryTypeBits);
>        return VK_NULL_HANDLE;
>    }
>
>    if ((vr = vkAllocateMemory(device, &allocate_info, NULL, &vk_memory)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate device memory, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return vk_memory;
>}
>
>static VkDeviceMemory allocate_buffer_memory(VkDevice device, VkPhysicalDevice physical_device,
>        VkBuffer buffer, VkMemoryPropertyFlags memory_flags)
>{
>    VkMemoryRequirements memory_requirements;
>    VkDeviceMemory memory;
>    VkResult vr;
>
>    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
>    memory = allocate_device_memory(device, physical_device, &memory_requirements,  memory_flags);
>    assert(memory != VK_NULL_HANDLE);
>
>    if ((vr = vkBindBufferMemory(device, buffer, memory, 0)) < 0)
>    {
>        fprintf(stderr, "Failed to bind memory, vr %d.\n", vr);
>        vkFreeMemory(device, memory, NULL);
>        return VK_NULL_HANDLE;
>    }
>    return memory;
>}
>
>static VkBufferView create_buffer_view(VkDevice device, VkBuffer buffer, VkFormat format)
>{
>    VkBufferViewCreateInfo create_info;
>    VkBufferView buffer_view;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = 0;
>    create_info.buffer = buffer;
>    create_info.format = format;
>    create_info.offset = 0;
>    create_info.range = VK_WHOLE_SIZE;
>
>    if ((vr = vkCreateBufferView(device, &create_info, NULL, &buffer_view)) < 0)
>    {
>        fprintf(stderr, "Failed to create buffer view, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>    return buffer_view;
>}
>
>static void cmd_buffer_barrier(VkCommandBuffer command_buffer, VkBuffer buffer,
>        VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
>        VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask)
>{
>    VkBufferMemoryBarrier buffer_barrier;
>
>    buffer_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
>    buffer_barrier.pNext = NULL;
>    buffer_barrier.srcAccessMask = src_access_mask;
>    buffer_barrier.dstAccessMask = dst_access_mask;
>    buffer_barrier.srcQueueFamilyIndex = 0;
>    buffer_barrier.dstQueueFamilyIndex = 0;
>    buffer_barrier.buffer = buffer;
>    buffer_barrier.offset = 0;
>    buffer_barrier.size = VK_WHOLE_SIZE;
>
>    vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0,
>            0, NULL,  1, &buffer_barrier, 0, NULL);
>}
>
>static void cmd_copy_buffer(VkCommandBuffer command_buffer,
>        VkBuffer src_buffer, VkBuffer dst_buffer,
>        VkDeviceSize src_offset, VkDeviceSize dst_offset, VkDeviceSize size)
>{
>    VkBufferCopy region;
>
>    region.srcOffset = src_offset;
>    region.dstOffset = dst_offset;
>    region.size = size;
>
>    vkCmdCopyBuffer(command_buffer, src_buffer, dst_buffer, 1, &region);
>}
>
>static void *map_memory(VkDevice device, VkDeviceMemory memory,
>        VkDeviceSize offset, VkDeviceSize size)
>{
>    VkResult vr;
>    void *ptr;
>
>    if ((vr = vkMapMemory(device, memory, offset, size, 0, &ptr)) < 0)
>    {
>        fprintf(stderr, "Failed to map memory, vr %d.\n", vr);
>        return NULL;
>    }
>    return ptr;
>}
>
>static uint32_t cs_code[] =
>{
>#if 0
>    ; SPIR-V
>    ; Version: 1.2
>    ; Generator: Khronos SPIR-V Tools Assembler; 0
>    ; Bound: 23
>    ; Schema: 0
>    OpCapability Shader
>    OpCapability SampledBuffer
>    OpCapability ImageBuffer
>    OpMemoryModel Logical GLSL450
>    OpEntryPoint GLCompute %1 "main"
>    OpExecutionMode %1 LocalSize 1 1 1
>    OpDecorate %2 DescriptorSet 0
>    OpDecorate %2 Binding 0
>    OpDecorate %3 DescriptorSet 0
>    OpDecorate %3 Binding 1
>    %void = OpTypeVoid
>    %5 = OpTypeFunction %void
>    %uint = OpTypeInt 32 0
>    %7 = OpTypeImage %uint Buffer 0 0 0 2 R32ui
>    %_ptr_UniformConstant_7 = OpTypePointer UniformConstant %7
>    %2 = OpVariable %_ptr_UniformConstant_7 UniformConstant
>    %3 = OpVariable %_ptr_UniformConstant_7 UniformConstant
>    %float = OpTypeFloat 32
>    %v4float = OpTypeVector %float 4
>    %_ptr_Function_v4float = OpTypePointer Function %v4float
>    %_ptr_Image_uint = OpTypePointer Image %uint
>    %uint_0 = OpConstant %uint 0
>    %uint_1 = OpConstant %uint 1
>    %_ptr_Function_float = OpTypePointer Function %float
>    %int = OpTypeInt 32 1
>    %v4uint = OpTypeVector %uint 4
>    %1 = OpFunction %void None %5
>    %18 = OpLabel
>    %19 = OpImageTexelPointer %_ptr_Image_uint %3 %uint_0 %uint_0
>    %20 = OpAtomicIDecrement %uint %19 %uint_1 %uint_0
>    %21 = OpLoad %7 %2
>    %22 = OpCompositeConstruct %v4uint %20 %20 %20 %20
>    OpImageWrite %21 %uint_0 %22
>    OpReturn
>    OpFunctionEnd
>#endif
>    0x07230203, 0x00010200, 0x00070000, 0x00000017, 0x00000000, 0x00020011, 0x00000001, 0x00020011,
>    0x0000002e, 0x00020011, 0x0000002f, 0x0003000e, 0x00000000, 0x00000001, 0x0005000f, 0x00000005,
>    0x00000001, 0x6e69616d, 0x00000000, 0x00060010, 0x00000001, 0x00000011, 0x00000001, 0x00000001,
>    0x00000001, 0x00040047, 0x00000002, 0x00000022, 0x00000000, 0x00040047, 0x00000002, 0x00000021,
>    0x00000000, 0x00040047, 0x00000003, 0x00000022, 0x00000000, 0x00040047, 0x00000003, 0x00000021,
>    0x00000001, 0x00020013, 0x00000004, 0x00030021, 0x00000005, 0x00000004, 0x00040015, 0x00000006,
>    0x00000020, 0x00000000, 0x00090019, 0x00000007, 0x00000006, 0x00000005, 0x00000000, 0x00000000,
>    0x00000000, 0x00000002, 0x00000021, 0x00040020, 0x00000008, 0x00000000, 0x00000007, 0x0004003b,
>    0x00000008, 0x00000002, 0x00000000, 0x0004003b, 0x00000008, 0x00000003, 0x00000000, 0x00030016,
>    0x00000009, 0x00000020, 0x00040017, 0x0000000a, 0x00000009, 0x00000004, 0x00040020, 0x0000000b,
>    0x00000007, 0x0000000a, 0x00040020, 0x0000000c, 0x0000000b, 0x00000006, 0x0004002b, 0x00000006,
>    0x0000000d, 0x00000000, 0x0004002b, 0x00000006, 0x0000000e, 0x00000001, 0x00040020, 0x0000000f,
>    0x00000007, 0x00000009, 0x00040015, 0x00000010, 0x00000020, 0x00000001, 0x00040017, 0x00000011,
>    0x00000006, 0x00000004, 0x00050036, 0x00000004, 0x00000001, 0x00000000, 0x00000005, 0x000200f8,
>    0x00000012, 0x0006003c, 0x0000000c, 0x00000013, 0x00000003, 0x0000000d, 0x0000000d, 0x000600e9,
>    0x00000006, 0x00000014, 0x00000013, 0x0000000e, 0x0000000d, 0x0004003d, 0x00000007, 0x00000015,
>    0x00000002, 0x00070050, 0x00000011, 0x00000016, 0x00000014, 0x00000014, 0x00000014, 0x00000014,
>    0x00040063, 0x00000015, 0x0000000d, 0x00000016, 0x000100fd, 0x00010038,
>};
>
>static uint32_t check_uint32(uint32_t value, uint32_t expected_value)
>{
>    if (value != expected_value)
>        printf("Got value %u, expected %u.\n", value, expected_value);
>}
>
>int main(void)
>{
>    VkDeviceMemory out_memory, counter_memory, readback_memory;
>    VkBuffer out_buffer, counter_buffer, readback_buffer;
>    VkBufferView out_buffer_view, counter_buffer_view;
>    VkWriteDescriptorSet write_descriptors[2];
>    VkPhysicalDevice physical_device;
>    VkDescriptorSetLayout set_layout;
>    VkDescriptorPool descriptor_pool;
>    VkCommandBuffer command_buffer;
>    VkCommandPool command_pool;
>    VkRenderPass render_pass;
>    VkPipelineLayout layout;
>    VkInstance instance;
>    VkPipeline pipeline;
>    VkDescriptorSet set;
>    VkShaderModule cs;
>    uint32_t *result;
>    VkDevice device;
>    unsigned int i;
>    VkQueue queue;
>
>    instance = create_instance();
>    assert(instance != VK_NULL_HANDLE);
>    physical_device = select_physical_device(instance);
>    assert(physical_device != VK_NULL_HANDLE);
>    device = create_device(instance, physical_device);
>    assert(device != VK_NULL_HANDLE);
>
>    set_layout = create_descriptor_set_layout(device);
>    assert(set_layout != VK_NULL_HANDLE);
>
>    layout = create_pipeline_layout(device, set_layout);
>    assert(layout != VK_NULL_HANDLE);
>
>    cs = create_shader_module(device, sizeof(cs_code), &cs_code);
>    assert(cs != VK_NULL_HANDLE);
>
>    pipeline = create_compute_pipeline(device, layout, cs);
>    assert(pipeline != VK_NULL_HANDLE);
>
>    descriptor_pool = create_descriptor_pool(device);
>    assert(descriptor_pool != VK_NULL_HANDLE);
>
>    set = allocate_descriptor_set(device, descriptor_pool, set_layout);
>    assert(set != VK_NULL_HANDLE);
>
>    vkGetDeviceQueue(device, 0, 0, &queue);
>
>    command_pool = create_command_pool(device, 0);
>    assert(command_pool != VK_NULL_HANDLE);
>
>    command_buffer = allocate_command_buffer(device, command_pool);
>    assert(command_buffer != VK_NULL_HANDLE);
>
>    /* create resources */
>    out_buffer = create_buffer(device, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT
>            | VK_BUFFER_USAGE_TRANSFER_DST_BIT
>            | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
>    assert(out_buffer != VK_NULL_HANDLE);
>    out_memory = allocate_buffer_memory(device, physical_device, out_buffer,
>            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
>    assert(out_memory != VK_NULL_HANDLE);
>    out_buffer_view = create_buffer_view(device, out_buffer, VK_FORMAT_R32_UINT);
>    assert(out_buffer_view != VK_NULL_HANDLE);
>
>    counter_buffer = create_buffer(device, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT
>            | VK_BUFFER_USAGE_TRANSFER_DST_BIT
>            | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
>    assert(counter_buffer != VK_NULL_HANDLE);
>    counter_memory = allocate_buffer_memory(device, physical_device, counter_buffer,
>            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
>    assert(counter_memory != VK_NULL_HANDLE);
>    counter_buffer_view = create_buffer_view(device, counter_buffer, VK_FORMAT_R32_UINT);
>    assert(counter_buffer_view != VK_NULL_HANDLE);
>
>    readback_buffer = create_buffer(device, 2 * sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT
>            | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
>    assert(readback_buffer != VK_NULL_HANDLE);
>    readback_memory = allocate_buffer_memory(device, physical_device, readback_buffer,
>            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
>    assert(readback_memory != VK_NULL_HANDLE);
>
>    memset(&write_descriptors, 0, sizeof(write_descriptors));
>    for (i = 0; i < ARRAY_SIZE(write_descriptors); ++i)
>    {
>        write_descriptors[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
>        write_descriptors[i].pNext = NULL;
>        write_descriptors[i].dstSet = set;
>        write_descriptors[i].dstBinding = i;
>        write_descriptors[i].descriptorCount = 1;
>        write_descriptors[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
>    }
>    write_descriptors[0].pTexelBufferView = &out_buffer_view;
>    write_descriptors[1].pTexelBufferView = &counter_buffer_view;
>    vkUpdateDescriptorSets(device, ARRAY_SIZE(write_descriptors), write_descriptors, 0, NULL);
>
>    /* records commands */
>    begin_command_buffer(command_buffer);
>
>    vkCmdFillBuffer(command_buffer, out_buffer, 0, VK_WHOLE_SIZE, 0xdeadbeef);
>    vkCmdFillBuffer(command_buffer, counter_buffer, 0, VK_WHOLE_SIZE, 8);
>    vkCmdFillBuffer(command_buffer, readback_buffer, 0, VK_WHOLE_SIZE, 0xdeadbabe);
>
>    cmd_buffer_barrier(command_buffer, out_buffer,
>            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
>            VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
>    cmd_buffer_barrier(command_buffer, counter_buffer,
>            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
>            VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
>
>    vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
>    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
>            layout, 0, 1, &set, 0, NULL);
>    vkCmdDispatch(command_buffer, 1, 1, 1);
>
>    cmd_buffer_barrier(command_buffer, out_buffer,
>            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
>            VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
>    cmd_buffer_barrier(command_buffer, counter_buffer,
>            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
>            VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT);
>
>    cmd_copy_buffer(command_buffer, out_buffer, readback_buffer, 0, 0, sizeof(uint32_t));
>    cmd_copy_buffer(command_buffer, counter_buffer, readback_buffer, 0, sizeof(uint32_t), sizeof(uint32_t));
>
>    cmd_buffer_barrier(command_buffer, readback_buffer,
>            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
>            VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
>
>    end_command_buffer(command_buffer);
>
>    submit_commands(device, queue, command_buffer, true);
>
>    vkDeviceWaitIdle(device);
>
>    /* check results */
>    result = map_memory(device, readback_memory, 0, VK_WHOLE_SIZE);
>    assert(result != NULL);
>
>    printf("%u %u\n", result[0], result[1]);
>    check_uint32(result[0], 8);
>    check_uint32(result[1], 7);
>
>    vkDeviceWaitIdle(device);
>
>    vkDestroyBufferView(device, out_buffer_view, NULL);
>    vkDestroyBufferView(device, counter_buffer_view, NULL);
>    vkDestroyBuffer(device, out_buffer, NULL);
>    vkDestroyBuffer(device, counter_buffer, NULL);
>    vkDestroyBuffer(device, readback_buffer, NULL);
>    vkFreeMemory(device, out_memory, NULL);
>    vkFreeMemory(device, counter_memory, NULL);
>    vkFreeMemory(device, readback_memory, NULL);
>
>    vkDestroyShaderModule(device, cs, NULL);
>    vkDestroyPipeline(device, pipeline, NULL);
>    vkDestroyPipelineLayout(device, layout, NULL);
>    vkDestroyDescriptorSetLayout(device, set_layout, NULL);
>    vkDestroyDescriptorPool(device, descriptor_pool, NULL);
>    vkDestroyCommandPool(device, command_pool, NULL);
>
>    vkDestroyDevice(device, NULL);
>    vkDestroyInstance(instance, NULL);
>    return 0;
>}

Actions: View

Attachments on bug 105320: 137738

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.