Attachment 144676 Details for Bug 111019 – Minimal reproducer

Minimal reproducer

variable-descriptor-count.c (text/x-csrc), 8.95 KB, created by Józef Kucia on 2019-06-28 17:06:42 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Józef Kucia

Created: 2019-06-28 17:06:42 UTC

Size: 8.95 KB

patch

obsolete

>/*
> * gcc -lvulkan variable-descriptor-count.c -o variable-descriptor-count
> */
>#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_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
>    VK_KHR_SURFACE_EXTENSION_NAME,
>    VK_KHR_XCB_SURFACE_EXTENSION_NAME,
>};
>
>static const char * const device_extensions[] =
>{
>    VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME,
>    VK_KHR_MAINTENANCE1_EXTENSION_NAME,
>    VK_KHR_MAINTENANCE3_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)
>{
>    VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features;
>    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);
>
>    memset(&descriptor_indexing_features, 0, sizeof(descriptor_indexing_features));
>    descriptor_indexing_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
>    descriptor_indexing_features.descriptorBindingSampledImageUpdateAfterBind = VK_TRUE;
>    descriptor_indexing_features.descriptorBindingVariableDescriptorCount = VK_TRUE;
>
>    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
>    device_info.pNext = &descriptor_indexing_features;
>    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 VkDescriptorSetLayout create_descriptor_set_layout(VkDevice device)
>{
>    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT binding_flags_info;
>    VkDescriptorSetLayoutCreateInfo create_info;
>    VkDescriptorBindingFlagsEXT binding_flags;
>    VkDescriptorSetLayoutBinding bindings[1];
>    VkDescriptorSetLayout layout;
>    VkResult vr;
>
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
>    create_info.pNext = &binding_flags_info;
>    create_info.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT;
>    create_info.bindingCount = ARRAY_SIZE(bindings);
>    create_info.pBindings = bindings;
>
>    binding_flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT
>            | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT;
>    binding_flags_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT;
>    binding_flags_info.pNext = NULL;
>    binding_flags_info.bindingCount = 1;
>    binding_flags_info.pBindingFlags = &binding_flags;
>
>    bindings[0].binding = 0;
>    bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
>    bindings[0].descriptorCount = 1024 * 4; /* upper limit */
>    bindings[0].stageFlags = VK_SHADER_STAGE_ALL;
>    bindings[0].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;
>}
>
>int main(int argc, char **argv)
>{
>    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT count_info;
>    VkDescriptorSetAllocateInfo allocate_info;
>    VkDescriptorPoolCreateInfo create_info;
>    VkDescriptorPoolSize pool_sizes[1];
>    VkPhysicalDevice physical_device;
>    VkDescriptorSetLayout set_layout;
>    VkDescriptorPool descriptor_pool;
>    VkInstance instance;
>    VkDescriptorSet set;
>    VkDevice device;
>    uint32_t count;
>    VkResult vr;
>
>    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);
>
>    // pool
>    create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
>    create_info.pNext = NULL;
>    create_info.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT;
>    create_info.maxSets = 32;
>    create_info.poolSizeCount = ARRAY_SIZE(pool_sizes);
>    create_info.pPoolSizes = pool_sizes;
>
>    pool_sizes[0].type = VK_DESCRIPTOR_TYPE_SAMPLER;
>    pool_sizes[0].descriptorCount = 1024;
>
>    if ((vr = vkCreateDescriptorPool(device, &create_info, NULL, &descriptor_pool)) < 0)
>    {
>        fprintf(stderr, "Failed to create descriptor pool, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>
>    // variable descriptor count
>    count = 1024;
>    count_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT;
>    count_info.pNext = NULL;
>    count_info.descriptorSetCount = 1;
>    count_info.pDescriptorCounts = &count;
>
>    // descriptor set
>    allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
>    allocate_info.pNext = &count_info;
>    allocate_info.descriptorPool = descriptor_pool;
>    allocate_info.descriptorSetCount = 1;
>    allocate_info.pSetLayouts = &set_layout;
>
>    /* This fails on radv */
>    if ((vr = vkAllocateDescriptorSets(device, &allocate_info, &set)) < 0)
>    {
>        fprintf(stderr, "Failed to allocate descriptor set, vr %d.\n", vr);
>        return VK_NULL_HANDLE;
>    }
>
>    fprintf(stdout, "Allocated descriptor set.\n");
>
>    vkDestroyDescriptorPool(device, descriptor_pool, NULL);
>    vkDestroyDescriptorSetLayout(device, set_layout, NULL);
>    vkDestroyDevice(device, NULL);
>    vkDestroyInstance(instance, NULL);
>    return 0;
>}

Actions: View

Attachments on bug 111019: 144676 | 144908

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.