Fix device mismatch bug by creating allocator for the sparse context too

diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
index 371698a..9b74320 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
+++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.cpp
@@ -534,7 +534,9 @@ TestInstance* ShaderRenderCase::createInstance (Context& context) const
 
 ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context)
        : vkt::TestInstance             (context)
-       , m_memAlloc                    (context.getDefaultAllocator())
+       , m_imageBackingMode    (IMAGE_BACKING_MODE_REGULAR)
+       , m_sparseContext               (createSparseContext())
+       , m_memAlloc                    (getAllocator())
        , m_clearColor                  (DEFAULT_CLEAR_COLOR)
        , m_isVertexCase                (false)
        , m_vertexShaderName    ("vert")
@@ -544,7 +546,6 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context)
        , m_evaluator                   (DE_NULL)
        , m_uniformSetup                (DE_NULL)
        , m_attribFunc                  (DE_NULL)
-       , m_sparseContext               (createSparseContext())
        , m_sampleCount                 (VK_SAMPLE_COUNT_1_BIT)
 {
 }
@@ -557,18 +558,18 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context&                                      context,
                                                                                                        const AttributeSetupFunc        attribFunc,
                                                                                                        const ImageBackingMode          imageBackingMode)
        : vkt::TestInstance             (context)
-       , m_memAlloc                    (context.getDefaultAllocator())
+       , m_imageBackingMode    (imageBackingMode)
+       , m_sparseContext               (createSparseContext())
+       , m_memAlloc                    (getAllocator())
        , m_clearColor                  (DEFAULT_CLEAR_COLOR)
        , m_isVertexCase                (isVertexCase)
        , m_vertexShaderName    ("vert")
        , m_fragmentShaderName  ("frag")
        , m_renderSize                  (128, 128)
        , m_colorFormat                 (VK_FORMAT_R8G8B8A8_UNORM)
-       , m_imageBackingMode    (imageBackingMode)
        , m_evaluator                   (&evaluator)
        , m_uniformSetup                (&uniformSetup)
        , m_attribFunc                  (attribFunc)
-       , m_sparseContext               (createSparseContext())
        , m_sampleCount                 (VK_SAMPLE_COUNT_1_BIT)
 {
 }
@@ -580,18 +581,18 @@ ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context&                                      context,
                                                                                                        const AttributeSetupFunc        attribFunc,
                                                                                                        const ImageBackingMode          imageBackingMode)
        : vkt::TestInstance             (context)
-       , m_memAlloc                    (context.getDefaultAllocator())
+       , m_imageBackingMode    (imageBackingMode)
+       , m_sparseContext               (createSparseContext())
+       , m_memAlloc                    (getAllocator())
        , m_clearColor                  (DEFAULT_CLEAR_COLOR)
        , m_isVertexCase                (isVertexCase)
        , m_vertexShaderName    ("vert")
        , m_fragmentShaderName  ("frag")
        , m_renderSize                  (128, 128)
        , m_colorFormat                 (VK_FORMAT_R8G8B8A8_UNORM)
-       , m_imageBackingMode    (imageBackingMode)
        , m_evaluator                   (evaluator)
        , m_uniformSetup                (uniformSetup)
        , m_attribFunc                  (attribFunc)
-       , m_sparseContext               (createSparseContext())
        , m_sampleCount                 (VK_SAMPLE_COUNT_1_BIT)
 {
 }
@@ -609,48 +610,76 @@ static deUint32 findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstanc
        TCU_THROW(NotSupportedError, "No matching queue found");
 }
 
-ShaderRenderCaseInstance::SparseContext* ShaderRenderCaseInstance::createSparseContext (void) const
+
+ShaderRenderCaseInstance::SparseContext::SparseContext (vkt::Context& context)
+       : m_context                             (context)
+       , m_queueFamilyIndex    (findQueueFamilyIndexWithCaps(context.getInstanceInterface(), context.getPhysicalDevice(), VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT))
+       , m_device                              (createDevice())
+       , m_deviceInterface             (context.getInstanceInterface(), *m_device)
+       , m_allocator                   (createAllocator())
 {
-       if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE)
-       {
-               const InstanceInterface&                vk                              = getInstanceInterface();
-               const VkPhysicalDevice                  physicalDevice  = getPhysicalDevice();
-               const VkPhysicalDeviceFeatures  deviceFeatures  = getPhysicalDeviceFeatures(vk, physicalDevice);
+       m_deviceInterface.getDeviceQueue(*m_device, m_queueFamilyIndex, 0, &m_queue);
+}
 
-               const deUint32 queueIndex = findQueueFamilyIndexWithCaps(vk, physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT);
+Move<VkDevice> ShaderRenderCaseInstance::SparseContext::createDevice () const
+{
+       const InstanceInterface&                                vk                                      = m_context.getInstanceInterface();
+       const VkPhysicalDevice                                  physicalDevice          = m_context.getPhysicalDevice();
+       const VkPhysicalDeviceFeatures                  deviceFeatures          = getPhysicalDeviceFeatures(vk, physicalDevice);
 
-               VkDeviceQueueCreateInfo                 queueInfo;
-               VkDeviceCreateInfo                              deviceInfo;
-               const float                                             queuePriority   = 1.0f;
+       VkDeviceQueueCreateInfo                                 queueInfo;
+       VkDeviceCreateInfo                                              deviceInfo;
+       const float                                                             queuePriority           = 1.0f;
 
-               deMemset(&queueInfo,    0, sizeof(queueInfo));
-               deMemset(&deviceInfo,   0, sizeof(deviceInfo));
+       deMemset(&queueInfo,    0, sizeof(queueInfo));
+       deMemset(&deviceInfo,   0, sizeof(deviceInfo));
 
-               queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-               queueInfo.pNext                                                 = DE_NULL;
-               queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
-               queueInfo.queueFamilyIndex                              = queueIndex;
-               queueInfo.queueCount                                    = 1u;
-               queueInfo.pQueuePriorities                              = &queuePriority;
+       queueInfo.sType                                                 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+       queueInfo.pNext                                                 = DE_NULL;
+       queueInfo.flags                                                 = (VkDeviceQueueCreateFlags)0u;
+       queueInfo.queueFamilyIndex                              = m_queueFamilyIndex;
+       queueInfo.queueCount                                    = 1u;
+       queueInfo.pQueuePriorities                              = &queuePriority;
 
-               deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-               deviceInfo.pNext                                                = DE_NULL;
-               deviceInfo.queueCreateInfoCount                 = 1u;
-               deviceInfo.pQueueCreateInfos                    = &queueInfo;
-               deviceInfo.enabledExtensionCount                = 0u;
-               deviceInfo.ppEnabledExtensionNames              = DE_NULL;
-               deviceInfo.enabledLayerCount                    = 0u;
-               deviceInfo.ppEnabledLayerNames                  = DE_NULL;
-               deviceInfo.pEnabledFeatures                             = &deviceFeatures;
+       deviceInfo.sType                                                = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+       deviceInfo.pNext                                                = DE_NULL;
+       deviceInfo.queueCreateInfoCount                 = 1u;
+       deviceInfo.pQueueCreateInfos                    = &queueInfo;
+       deviceInfo.enabledExtensionCount                = 0u;
+       deviceInfo.ppEnabledExtensionNames              = DE_NULL;
+       deviceInfo.enabledLayerCount                    = 0u;
+       deviceInfo.ppEnabledLayerNames                  = DE_NULL;
+       deviceInfo.pEnabledFeatures                             = &deviceFeatures;
 
-               Move<VkDevice>  device = createDevice(vk, physicalDevice, &deviceInfo);
+       return vk::createDevice(vk, physicalDevice, &deviceInfo);
+}
+
+vk::Allocator* ShaderRenderCaseInstance::SparseContext::createAllocator        () const
+{
+       const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
+       return new SimpleAllocator(m_deviceInterface, *m_device, memoryProperties);
+}
 
-               return new SparseContext(device, queueIndex, vk);
+ShaderRenderCaseInstance::SparseContext* ShaderRenderCaseInstance::createSparseContext (void) const
+{
+       if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE)
+       {
+               return new SparseContext(m_context);
        }
 
        return DE_NULL;
 }
 
+vk::Allocator& ShaderRenderCaseInstance::getAllocator (void) const
+{
+       if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE)
+       {
+               return *m_sparseContext->m_allocator;
+       }
+
+       return m_context.getDefaultAllocator();
+}
+
 ShaderRenderCaseInstance::~ShaderRenderCaseInstance (void)
 {
 }
@@ -666,7 +695,7 @@ VkDevice ShaderRenderCaseInstance::getDevice (void) const
 deUint32 ShaderRenderCaseInstance::getUniversalQueueFamilyIndex        (void) const
 {
        if (m_imageBackingMode == IMAGE_BACKING_MODE_SPARSE)
-               return m_sparseContext->m_universalQueueFamilyIndex;
+               return m_sparseContext->m_queueFamilyIndex;
 
        return m_context.getUniversalQueueFamilyIndex();
 }
@@ -1309,7 +1338,7 @@ void ShaderRenderCaseInstance::uploadSparseImage (const tcu::TextureFormat&               tex
        const bool                                                              isShadowSampler                 = refSampler.compare != tcu::Sampler::COMPAREMODE_NONE;
        const VkImageAspectFlags                                aspectMask                              = isShadowSampler ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
 
-       const Unique<VkSemaphore>                               imageMemoryBindSemaphore(makeSemaphore(vk, vkDevice));
+       const Unique<VkSemaphore>                               imageMemoryBindSemaphore(makeSemaphore(vk, vkDevice));
        deUint32                                                                bufferSize                              = 0u;
        std::vector<deUint32>                                   offsetMultiples;
        offsetMultiples.push_back(4u);
@@ -2379,7 +2408,7 @@ void ShaderRenderCaseInstance::render (deUint32                           numVertices,
                descriptorSetLayout = m_descriptorSetLayoutBuilder->build(vk, vkDevice);
                if (!m_uniformInfos.empty())
                {
-                       descriptorPool                                                                  = m_descriptorPoolBuilder->build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+                       descriptorPool                                                                  = m_descriptorPoolBuilder->build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
                        const VkDescriptorSetAllocateInfo       allocInfo       =
                        {
                                VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,

diff --git a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp
index c0cc791..8e63124 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp
+++ b/external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp
@@ -484,6 +484,27 @@ protected:
 
        bool                                                                                            isMultiSampling                         (void) const;
 
+       ImageBackingMode                                                                        m_imageBackingMode;
+private:
+
+       struct SparseContext
+       {
+                                                                                       SparseContext   (vkt::Context& context);
+
+               vkt::Context&                                           m_context;
+               const deUint32                                          m_queueFamilyIndex;
+               vk::Unique<vk::VkDevice>                        m_device;
+               vk::DeviceDriver                                        m_deviceInterface;
+               vk::VkQueue                                                     m_queue;
+               const de::UniquePtr<vk::Allocator>      m_allocator;
+       private:
+               vk::Move<vk::VkDevice>                          createDevice    (void) const;
+               vk::Allocator*                                          createAllocator (void) const;
+
+       };
+
+       de::UniquePtr<SparseContext>                                            m_sparseContext;
+protected:
        vk::Allocator&                                                                          m_memAlloc;
        const tcu::Vec4                                                                         m_clearColor;
        const bool                                                                                      m_isVertexCase;
@@ -495,7 +516,6 @@ protected:
        std::string                                                                                     m_fragmentShaderName;
        tcu::UVec2                                                                                      m_renderSize;
        vk::VkFormat                                                                            m_colorFormat;
-       ImageBackingMode                                                                        m_imageBackingMode;
 
 private:
        typedef std::vector<tcu::ConstPixelBufferAccess>        TextureLayerData;
@@ -541,24 +561,6 @@ private:
        const ShaderEvaluator*                                                          m_evaluator;
        const UniformSetup*                                                                     m_uniformSetup;
        const AttributeSetupFunc                                                        m_attribFunc;
-
-       struct SparseContext
-       {
-               SparseContext (vk::Move<vk::VkDevice>& device, const deUint32 universalQueueFamilyIndex, const vk::InstanceInterface& interface)
-               : m_device                                              (device)
-               , m_universalQueueFamilyIndex   (universalQueueFamilyIndex)
-               , m_deviceInterface                             (interface, *m_device)
-               {
-                       m_deviceInterface.getDeviceQueue(*m_device, m_universalQueueFamilyIndex, 0, &m_queue);
-               }
-
-               vk::Unique<vk::VkDevice>        m_device;
-               const deUint32                          m_universalQueueFamilyIndex;
-               vk::DeviceDriver                        m_deviceInterface;
-               vk::VkQueue                                     m_queue;
-       };
-
-       de::UniquePtr<SparseContext>                                            m_sparseContext;
        de::MovePtr<QuadGrid>                                                           m_quadGrid;
        tcu::TextureLevel                                                                       m_resultImage;
 
@@ -631,7 +633,8 @@ private:
        vk::VkQueue                                                                                     getUniversalQueue                               (void) const;
        vk::VkPhysicalDevice                                                            getPhysicalDevice                               (void) const;
        const vk::InstanceInterface&                                            getInstanceInterface                    (void) const;
-       SparseContext*                                                                          createSparseContext     (void) const;
+       SparseContext*                                                                          createSparseContext                             (void) const;
+       vk::Allocator&                                                                          getAllocator                                    (void) const;
 };
 
 template<typename T>