Google Git
Sign in
fuchsia / third_party / vulkan-cts / aee749622c8168adb99fc5eb8bee8607966d484d / . / external / vulkancts / modules / vulkan / memory / vktMemoryDeviceMemoryReportTests.cpp
blob: 05ffbc15ec884b57c6e0a7bf15cca6993d9c4f16 [file] [log] [blame]
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
*
* Copyright (c) 2020 The Khronos Group Inc.
* Copyright (c) 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief VK_EXT_device_memory_report extension tests.
*//*--------------------------------------------------------------------*/
#include "vktMemoryDeviceMemoryReportTests.hpp"
#include "vktCustomInstancesDevices.hpp"
#include "vktExternalMemoryUtil.hpp"
#include "vktTestCaseUtil.hpp"
#include "vkDeviceUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTestCase.hpp"
#include "tcuTestLog.hpp"
#include "deSharedPtr.hpp"
#include <set>
#include <vector>
#include <limits>
namespace vkt
{
namespace memory
{
namespace
{
#define VK_DESCRIPTOR_TYPE_LAST (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT + 1)
using namespace vk;
using namespace vkt::ExternalMemoryUtil;
using de::MovePtr;
using de::SharedPtr;
enum CallbackMarker
{
MARKER_UNKNOWN = 0,
MARKER_ALLOCATE,
MARKER_FREE,
MARKER_IMPORT,
MARKER_UNIMPORT,
MARKER_ALLOCATION_FAILED
};
class CallbackRecorder
{
public:
CallbackRecorder(void): mMarker(MARKER_UNKNOWN) {}
~CallbackRecorder(void) = default;
typedef std::vector<std::pair<VkDeviceMemoryReportCallbackDataEXT, CallbackMarker>>::const_iterator RecordIterator;
RecordIterator getRecordsBegin (void) const
{
return mRecords.begin();
}
RecordIterator getRecordsEnd (void) const
{
return mRecords.end();
}
std::size_t getNumRecords (void) const
{
return mRecords.size();
}
void setCallbackMarker(CallbackMarker marker)
{
mMarker = marker;
}
void callbackInternal (const VkDeviceMemoryReportCallbackDataEXT* pCallbackData)
{
mRecords.emplace_back(*pCallbackData, mMarker);
}
static VKAPI_ATTR void VKAPI_CALL callback (const struct VkDeviceMemoryReportCallbackDataEXT* pCallbackData, void* pUserData)
{
reinterpret_cast<CallbackRecorder*>(pUserData)->callbackInternal(pCallbackData);
}
private:
typedef std::vector<std::pair<VkDeviceMemoryReportCallbackDataEXT, CallbackMarker>> Records;
Records mRecords;
CallbackMarker mMarker;
};
struct Environment
{
const PlatformInterface& vkp;
const InstanceInterface& vki;
VkInstance instance;
VkPhysicalDevice physicalDevice;
const DeviceInterface& vkd;
VkDevice device;
deUint32 queueFamilyIndex;
const BinaryCollection& programBinaries;
const tcu::CommandLine& commandLine;
const CallbackRecorder* recorder;
Environment (const PlatformInterface& vkp_,
const InstanceInterface& vki_,
VkInstance instance_,
VkPhysicalDevice physicalDevice_,
const DeviceInterface& vkd_,
VkDevice device_,
deUint32 queueFamilyIndex_,
const BinaryCollection& programBinaries_,
const tcu::CommandLine& commandLine_,
const CallbackRecorder* recorder_)
: vkp (vkp_)
, vki (vki_)
, instance (instance_)
, physicalDevice (physicalDevice_)
, vkd (vkd_)
, device (device_)
, queueFamilyIndex (queueFamilyIndex_)
, programBinaries (programBinaries_)
, commandLine (commandLine_)
, recorder (recorder_)
{
}
};
template<typename Case>
struct Dependency
{
typename Case::Resources resources;
Unique<typename Case::Type> object;
Dependency (const Environment& env, const typename Case::Parameters& params)
: resources (env, params)
, object (Case::create(env, resources, params))
{}
};
static Move<VkDevice> createDeviceWithMemoryReport (deBool isValidationEnabled,
const PlatformInterface& vkp,
VkInstance instance,
const InstanceInterface& vki,
VkPhysicalDevice physicalDevice,
deUint32 queueFamilyIndex,
const CallbackRecorder* recorder)
{
const deUint32 queueCount = 1;
const float queuePriority = 1.0f;
const char* const enabledExtensions[] = {"VK_EXT_device_memory_report"};
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, // VkStructureType sType;
DE_NULL, // void* pNext;
VK_TRUE // VkBool32 deviceMemoryReport;
};
const VkDeviceDeviceMemoryReportCreateInfoEXT deviceMemoryReportCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, // VkStructureType sType;
&deviceMemoryReportFeatures, // void* pNext;
(VkDeviceMemoryReportFlagsEXT)0, // VkDeviceMemoryReportFlagsEXT flags;
recorder->callback, // PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
(void*)recorder, // void* pUserData;
};
const VkDeviceQueueCreateInfo queueCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
queueFamilyIndex, // deUint32 queueFamilyIndex;
queueCount, // deUint32 queueCount;
&queuePriority, // const float* pQueuePriorities;
};
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
&deviceMemoryReportCreateInfo, // const void* pNext;
(VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
queueCount, // uint32_t queueCreateInfoCount;
&queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
0u, // uint32_t enabledLayerCount
DE_NULL, // const char* const* ppEnabledLayerNames
DE_LENGTH_OF_ARRAY(enabledExtensions), // uint32_t enabledExtensionCount
DE_ARRAY_BEGIN(enabledExtensions), // const char* const* ppEnabledExtensionNames
DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures
};
return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
}
struct Device
{
typedef VkDevice Type;
struct Parameters
{
Parameters (void) {}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkDevice> create (const Environment& env, const Resources&, const Parameters&)
{
return createDeviceWithMemoryReport(env.commandLine.isValidationEnabled(), env.vkp, env.instance, env.vki, env.physicalDevice, env.queueFamilyIndex, env.recorder);
}
};
struct DeviceMemory
{
typedef VkDeviceMemory Type;
struct Parameters
{
VkDeviceSize size;
deUint32 memoryTypeIndex;
Parameters (VkDeviceSize size_, deUint32 memoryTypeIndex_)
: size (size_)
, memoryTypeIndex (memoryTypeIndex_)
{
DE_ASSERT(memoryTypeIndex < VK_MAX_MEMORY_TYPES);
}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkDeviceMemory> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkMemoryAllocateInfo memoryAllocateInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.size, // VkDeviceSize allocationSize;
params.memoryTypeIndex, // uint32_t memoryTypeIndex;
};
return allocateMemory(env.vkd, env.device, &memoryAllocateInfo);
}
};
DeviceMemory::Parameters getDeviceMemoryParameters (const VkMemoryRequirements& memReqs)
{
return DeviceMemory::Parameters(memReqs.size, deCtz32(memReqs.memoryTypeBits));
}
DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkImage image)
{
return getDeviceMemoryParameters(getImageMemoryRequirements(env.vkd, env.device, image));
}
DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkBuffer buffer)
{
return getDeviceMemoryParameters(getBufferMemoryRequirements(env.vkd, env.device, buffer));
}
struct Buffer
{
typedef VkBuffer Type;
struct Parameters
{
VkDeviceSize size;
VkBufferUsageFlags usage;
Parameters (VkDeviceSize size_,
VkBufferUsageFlags usage_)
: size (size_)
, usage (usage_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkBuffer> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkBufferCreateInfo bufferCreateInfo =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
params.size, // VkDeviceSize size;
params.usage, // VkBufferUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // uint32_t queueFamilyIndexCount;
&env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
};
return createBuffer(env.vkd, env.device, &bufferCreateInfo);
}
};
struct BufferView
{
typedef VkBufferView Type;
struct Parameters
{
Buffer::Parameters buffer;
VkFormat format;
VkDeviceSize offset;
VkDeviceSize range;
Parameters (const Buffer::Parameters& buffer_,
VkFormat format_,
VkDeviceSize offset_,
VkDeviceSize range_)
: buffer (buffer_)
, format (format_)
, offset (offset_)
, range (range_)
{}
};
struct Resources
{
Dependency<Buffer> buffer;
Dependency<DeviceMemory> memory;
Resources (const Environment& env, const Parameters& params)
: buffer(env, params.buffer)
, memory(env, getDeviceMemoryParameters(env, *buffer.object))
{
VK_CHECK(env.vkd.bindBufferMemory(env.device, *buffer.object, *memory.object, 0));
}
};
static Move<VkBufferView> create (const Environment& env, const Resources& res, const Parameters& params)
{
const VkBufferViewCreateInfo bufferViewCreateInfo =
{
VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkBufferViewCreateFlags)0, // VkBufferViewCreateFlags flags;
*res.buffer.object, // VkBuffer buffer;
params.format, // VkFormat format;
params.offset, // VkDeviceSize offset;
params.range, // VkDeviceSize range;
};
return createBufferView(env.vkd, env.device, &bufferViewCreateInfo);
}
};
struct Image
{
typedef VkImage Type;
struct Parameters
{
VkImageCreateFlags flags;
VkImageType imageType;
VkFormat format;
VkExtent3D extent;
deUint32 mipLevels;
deUint32 arraySize;
VkSampleCountFlagBits samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkImageLayout initialLayout;
Parameters (VkImageCreateFlags flags_,
VkImageType imageType_,
VkFormat format_,
VkExtent3D extent_,
deUint32 mipLevels_,
deUint32 arraySize_,
VkSampleCountFlagBits samples_,
VkImageTiling tiling_,
VkImageUsageFlags usage_,
VkImageLayout initialLayout_)
: flags (flags_)
, imageType (imageType_)
, format (format_)
, extent (extent_)
, mipLevels (mipLevels_)
, arraySize (arraySize_)
, samples (samples_)
, tiling (tiling_)
, usage (usage_)
, initialLayout (initialLayout_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkImage> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkImageCreateInfo imageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkImageCreateFlags flags;
params.imageType, // VkImageType imageType;
params.format, // VkFormat format;
params.extent, // VkExtent3D extent;
params.mipLevels, // uint32_t mipLevels;
params.arraySize, // uint32_t arrayLayers;
params.samples, // VkSampleCountFlagBits samples;
params.tiling, // VkImageTiling tiling;
params.usage, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // uint32_t queueFamilyIndexCount;
&env.queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
params.initialLayout, // VkImageLayout initialLayout;
};
return createImage(env.vkd, env.device, &imageCreateInfo);
}
};
struct ImageView
{
typedef VkImageView Type;
struct Parameters
{
Image::Parameters image;
VkImageViewType viewType;
VkFormat format;
VkComponentMapping components;
VkImageSubresourceRange subresourceRange;
Parameters (const Image::Parameters& image_,
VkImageViewType viewType_,
VkFormat format_,
VkComponentMapping components_,
VkImageSubresourceRange subresourceRange_)
: image (image_)
, viewType (viewType_)
, format (format_)
, components (components_)
, subresourceRange (subresourceRange_)
{}
};
struct Resources
{
Dependency<Image> image;
Dependency<DeviceMemory> memory;
Resources (const Environment& env, const Parameters& params)
: image (env, params.image)
, memory(env, getDeviceMemoryParameters(env, *image.object))
{
VK_CHECK(env.vkd.bindImageMemory(env.device, *image.object, *memory.object, 0));
}
};
static Move<VkImageView> create (const Environment& env, const Resources& res, const Parameters& params)
{
const VkImageViewCreateInfo imageViewCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags;
*res.image.object, // VkImage image;
params.viewType, // VkImageViewType viewType;
params.format, // VkFormat format;
params.components, // VkComponentMapping components;
params.subresourceRange, // VkImageSubresourceRange subresourceRange;
};
return createImageView(env.vkd, env.device, &imageViewCreateInfo);
}
};
struct Semaphore
{
typedef VkSemaphore Type;
struct Parameters
{
VkSemaphoreCreateFlags flags;
Parameters (VkSemaphoreCreateFlags flags_)
: flags(flags_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkSemaphore> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkSemaphoreCreateInfo semaphoreCreateInfo =
{
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkSemaphoreCreateFlags flags;
};
return createSemaphore(env.vkd, env.device, &semaphoreCreateInfo);
}
};
struct Fence
{
typedef VkFence Type;
struct Parameters
{
VkFenceCreateFlags flags;
Parameters (VkFenceCreateFlags flags_)
: flags(flags_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkFence> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkFenceCreateInfo fenceCreateInfo =
{
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkFenceCreateFlags flags;
};
return createFence(env.vkd, env.device, &fenceCreateInfo);
}
};
struct Event
{
typedef VkEvent Type;
struct Parameters
{
VkEventCreateFlags flags;
Parameters (VkEventCreateFlags flags_)
: flags(flags_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkEvent> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkEventCreateInfo eventCreateInfo =
{
VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkEventCreateFlags flags;
};
return createEvent(env.vkd, env.device, &eventCreateInfo);
}
};
struct QueryPool
{
typedef VkQueryPool Type;
struct Parameters
{
VkQueryType queryType;
deUint32 entryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
Parameters (VkQueryType queryType_,
deUint32 entryCount_,
VkQueryPipelineStatisticFlags pipelineStatistics_)
: queryType (queryType_)
, entryCount (entryCount_)
, pipelineStatistics (pipelineStatistics_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkQueryPool> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkQueryPoolCreateInfo queryPoolCreateInfo =
{
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
params.queryType, // VkQueryType queryType;
params.entryCount, // uint32_t queryCount;
params.pipelineStatistics, // VkQueryPipelineStatisticFlags pipelineStatistics;
};
return createQueryPool(env.vkd, env.device, &queryPoolCreateInfo);
}
};
struct ShaderModule
{
typedef VkShaderModule Type;
struct Parameters
{
VkShaderStageFlagBits shaderStage;
std::string binaryName;
Parameters (VkShaderStageFlagBits shaderStage_,
const std::string& binaryName_)
: shaderStage (shaderStage_)
, binaryName (binaryName_)
{}
};
struct Resources
{
const ProgramBinary& binary;
Resources (const Environment& env, const Parameters& params)
: binary(env.programBinaries.get(params.binaryName))
{}
};
static const char* getSource (VkShaderStageFlagBits stage)
{
switch (stage)
{
case VK_SHADER_STAGE_VERTEX_BIT:
return "#version 310 es\n"
"layout(location = 0) in highp vec4 a_position;\n"
"void main () { gl_Position = a_position; }\n";
case VK_SHADER_STAGE_FRAGMENT_BIT:
return "#version 310 es\n"
"layout(location = 0) out mediump vec4 o_color;\n"
"void main () { o_color = vec4(1.0, 0.5, 0.25, 1.0); }";
case VK_SHADER_STAGE_COMPUTE_BIT:
return "#version 310 es\n"
"layout(binding = 0) buffer Input { highp uint dataIn[]; };\n"
"layout(binding = 1) buffer Output { highp uint dataOut[]; };\n"
"void main (void)\n"
"{\n"
" dataOut[gl_GlobalInvocationID.x] = ~dataIn[gl_GlobalInvocationID.x];\n"
"}\n";
default:
DE_FATAL("Not implemented");
return DE_NULL;
}
}
static void initPrograms (SourceCollections& dst, Parameters params)
{
const char* const source = getSource(params.shaderStage);
DE_ASSERT(source);
dst.glslSources.add(params.binaryName)
<< glu::ShaderSource(getGluShaderType(params.shaderStage), source);
}
static Move<VkShaderModule> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkShaderModuleCreateInfo shaderModuleCreateInfo =
{
VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkShaderModuleCreateFlags)0, // VkShaderModuleCreateFlags flags;
res.binary.getSize(), // size_t codeSize;
(const deUint32*)res.binary.getBinary(), // const uint32_t* pCode;
};
return createShaderModule(env.vkd, env.device, &shaderModuleCreateInfo);
}
};
struct PipelineCache
{
typedef VkPipelineCache Type;
struct Parameters
{
Parameters (void) {}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkPipelineCache> create (const Environment& env, const Resources&, const Parameters&)
{
const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineCacheCreateFlags)0u, // VkPipelineCacheCreateFlags flags;
0u, // size_t initialDataSize;
DE_NULL, // const void* pInitialData;
};
return createPipelineCache(env.vkd, env.device, &pipelineCacheCreateInfo);
}
};
struct Sampler
{
typedef VkSampler Type;
struct Parameters
{
VkFilter magFilter;
VkFilter minFilter;
VkSamplerMipmapMode mipmapMode;
VkSamplerAddressMode addressModeU;
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
VkBool32 unnormalizedCoordinates;
Parameters (void)
: magFilter (VK_FILTER_NEAREST)
, minFilter (VK_FILTER_NEAREST)
, mipmapMode (VK_SAMPLER_MIPMAP_MODE_NEAREST)
, addressModeU (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, addressModeV (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, addressModeW (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, mipLodBias (0.0f)
, anisotropyEnable (VK_FALSE)
, maxAnisotropy (1.0f)
, compareEnable (VK_FALSE)
, compareOp (VK_COMPARE_OP_ALWAYS)
, minLod (-1000.f)
, maxLod (+1000.f)
, borderColor (VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK)
, unnormalizedCoordinates (VK_FALSE)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkSampler> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkSamplerCreateInfo samplerCreateInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkSamplerCreateFlags)0, // VkSamplerCreateFlags flags;
params.magFilter, // VkFilter magFilter;
params.minFilter, // VkFilter minFilter;
params.mipmapMode, // VkSamplerMipmapMode mipmapMode;
params.addressModeU, // VkSamplerAddressMode addressModeU;
params.addressModeV, // VkSamplerAddressMode addressModeV;
params.addressModeW, // VkSamplerAddressMode addressModeW;
params.mipLodBias, // float mipLodBias;
params.anisotropyEnable, // VkBool32 anisotropyEnable;
params.maxAnisotropy, // float maxAnisotropy;
params.compareEnable, // VkBool32 compareEnable;
params.compareOp, // VkCompareOp compareOp;
params.minLod, // float minLod;
params.maxLod, // float maxLod;
params.borderColor, // VkBorderColor borderColor;
params.unnormalizedCoordinates, // VkBool32 unnormalizedCoordinates;
};
return createSampler(env.vkd, env.device, &samplerCreateInfo);
}
};
struct DescriptorSetLayout
{
typedef VkDescriptorSetLayout Type;
struct Parameters
{
struct Binding
{
deUint32 binding;
VkDescriptorType descriptorType;
deUint32 descriptorCount;
VkShaderStageFlags stageFlags;
bool useImmutableSampler;
Binding (deUint32 binding_,
VkDescriptorType descriptorType_,
deUint32 descriptorCount_,
VkShaderStageFlags stageFlags_,
bool useImmutableSampler_)
: binding (binding_)
, descriptorType (descriptorType_)
, descriptorCount (descriptorCount_)
, stageFlags (stageFlags_)
, useImmutableSampler (useImmutableSampler_)
{}
Binding (void) {}
};
std::vector<Binding> bindings;
Parameters (const std::vector<Binding>& bindings_)
: bindings(bindings_)
{}
static Parameters empty (void)
{
return Parameters(std::vector<Binding>());
}
static Parameters single (deUint32 binding,
VkDescriptorType descriptorType,
deUint32 descriptorCount,
VkShaderStageFlags stageFlags,
bool useImmutableSampler = false)
{
std::vector<Binding> bindings;
bindings.push_back(Binding(binding, descriptorType, descriptorCount, stageFlags, useImmutableSampler));
return Parameters(bindings);
}
};
struct Resources
{
std::vector<VkDescriptorSetLayoutBinding> bindings;
MovePtr<Dependency<Sampler>> immutableSampler;
std::vector<VkSampler> immutableSamplersPtr;
Resources (const Environment& env, const Parameters& params)
{
for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
{
if (cur->useImmutableSampler && !immutableSampler)
{
immutableSampler = de::newMovePtr<Dependency<Sampler>>(env, Sampler::Parameters());
if (cur->useImmutableSampler && immutableSamplersPtr.size() < (size_t)cur->descriptorCount)
immutableSamplersPtr.resize(cur->descriptorCount, *immutableSampler->object);
}
}
for (std::vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
{
const VkDescriptorSetLayoutBinding binding =
{
cur->binding, // uint32_t binding;
cur->descriptorType, // VkDescriptorType descriptorType;
cur->descriptorCount, // uint32_t descriptorCount;
cur->stageFlags, // VkShaderStageFlags stageFlags;
(cur->useImmutableSampler ? &immutableSamplersPtr[0] : DE_NULL), // const VkSampler* pImmutableSamplers;
};
bindings.push_back(binding);
}
}
};
static Move<VkDescriptorSetLayout> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkDescriptorSetLayoutCreateFlags)0, // VkDescriptorSetLayoutCreateFlags flags;
(deUint32)res.bindings.size(), // uint32_t bindingCount;
(res.bindings.empty() ? DE_NULL : &res.bindings[0]), // const VkDescriptorSetLayoutBinding* pBindings;
};
return createDescriptorSetLayout(env.vkd, env.device, &descriptorSetLayoutCreateInfo);
}
};
struct PipelineLayout
{
typedef VkPipelineLayout Type;
struct Parameters
{
std::vector<DescriptorSetLayout::Parameters> descriptorSetLayouts;
std::vector<VkPushConstantRange> pushConstantRanges;
Parameters (void) {}
static Parameters empty (void)
{
return Parameters();
}
static Parameters singleDescriptorSet (const DescriptorSetLayout::Parameters& descriptorSetLayout)
{
Parameters params;
params.descriptorSetLayouts.push_back(descriptorSetLayout);
return params;
}
};
struct Resources
{
typedef SharedPtr<Dependency<DescriptorSetLayout>> DescriptorSetLayoutDepSp;
typedef std::vector<DescriptorSetLayoutDepSp> DescriptorSetLayouts;
DescriptorSetLayouts descriptorSetLayouts;
std::vector<VkDescriptorSetLayout> pSetLayouts;
Resources (const Environment& env, const Parameters& params)
{
for (std::vector<DescriptorSetLayout::Parameters>::const_iterator dsParams = params.descriptorSetLayouts.begin();
dsParams != params.descriptorSetLayouts.end();
++dsParams)
{
descriptorSetLayouts.push_back(DescriptorSetLayoutDepSp(new Dependency<DescriptorSetLayout>(env, *dsParams)));
pSetLayouts.push_back(*descriptorSetLayouts.back()->object);
}
}
};
static Move<VkPipelineLayout> create (const Environment& env, const Resources& res, const Parameters& params)
{
const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
(deUint32)res.pSetLayouts.size(), // uint32_t setLayoutCount;
(res.pSetLayouts.empty() ? DE_NULL : &res.pSetLayouts[0]), // const VkDescriptorSetLayout* pSetLayouts;
(deUint32)params.pushConstantRanges.size(), // uint32_t pushConstantRangeCount;
(params.pushConstantRanges.empty() ? DE_NULL : &params.pushConstantRanges[0]), // const VkPushConstantRange* pPushConstantRanges;
};
return createPipelineLayout(env.vkd, env.device, &pipelineLayoutCreateInfo);
}
};
struct RenderPass
{
typedef VkRenderPass Type;
struct Parameters
{
Parameters (void) {}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkRenderPass> create (const Environment& env, const Resources&, const Parameters&)
{
return makeRenderPass(env.vkd, env.device, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_D16_UNORM,
VK_ATTACHMENT_LOAD_OP_CLEAR,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
}
};
struct GraphicsPipeline
{
typedef VkPipeline Type;
struct Parameters
{
Parameters (void) {}
};
struct Resources
{
Dependency<ShaderModule> vertexShader;
Dependency<ShaderModule> fragmentShader;
Dependency<PipelineLayout> layout;
Dependency<RenderPass> renderPass;
Dependency<PipelineCache> pipelineCache;
Resources (const Environment& env, const Parameters&)
: vertexShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"))
, fragmentShader (env, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"))
, layout (env, PipelineLayout::Parameters::singleDescriptorSet(
DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u, VK_SHADER_STAGE_FRAGMENT_BIT, true)))
, renderPass (env, RenderPass::Parameters())
, pipelineCache (env, PipelineCache::Parameters())
{}
};
static void initPrograms (SourceCollections& dst, Parameters)
{
ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"));
ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"));
}
static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkPipelineShaderStageCreateInfo stages[] =
{
{
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
*res.vertexShader.object, // VkShaderModule module;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
},
{
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
*res.fragmentShader.object, // VkShaderModule module;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
}
};
const VkVertexInputBindingDescription vertexBindings[] =
{
{
0u, // uint32_t binding;
16u, // uint32_t stride;
VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
}
};
const VkVertexInputAttributeDescription vertexAttribs[] =
{
{
0u, // uint32_t location;
0u, // uint32_t binding;
VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
0u, // uint32_t offset;
}
};
const VkPipelineVertexInputStateCreateInfo vertexInputState =
{
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
DE_LENGTH_OF_ARRAY(vertexBindings), // uint32_t vertexBindingDescriptionCount;
vertexBindings, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
DE_LENGTH_OF_ARRAY(vertexAttribs), // uint32_t vertexAttributeDescriptionCount;
vertexAttribs, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
};
const VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
{
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // VkPrimitiveTopology topology;
VK_FALSE, // VkBool32 primitiveRestartEnable;
};
const VkViewport viewport = makeViewport(tcu::UVec2(64));
const VkRect2D scissor = makeRect2D(tcu::UVec2(64));
const VkPipelineViewportStateCreateInfo viewportState =
{
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
1u, // uint32_t viewportCount;
&viewport, // const VkViewport* pViewports;
1u, // uint32_t scissorCount;
&scissor, // const VkRect2D* pScissors;
};
const VkPipelineRasterizationStateCreateInfo rasterState =
{
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
VK_FALSE, // VkBool32 depthClampEnable;
VK_FALSE, // VkBool32 rasterizerDiscardEnable;
VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
VK_CULL_MODE_BACK_BIT, // VkCullModeFlags cullMode;
VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
VK_FALSE, // VkBool32 depthBiasEnable;
0.0f, // float depthBiasConstantFactor;
0.0f, // float depthBiasClamp;
0.0f, // float depthBiasSlopeFactor;
1.0f, // float lineWidth;
};
const VkPipelineMultisampleStateCreateInfo multisampleState =
{
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
VK_FALSE, // VkBool32 sampleShadingEnable;
1.0f, // float minSampleShading;
DE_NULL, // const VkSampleMask* pSampleMask;
VK_FALSE, // VkBool32 alphaToCoverageEnable;
VK_FALSE, // VkBool32 alphaToOneEnable;
};
const VkPipelineDepthStencilStateCreateInfo depthStencilState =
{
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
VK_TRUE, // VkBool32 depthTestEnable;
VK_TRUE, // VkBool32 depthWriteEnable;
VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
VK_FALSE, // VkBool32 depthBoundsTestEnable;
VK_FALSE, // VkBool32 stencilTestEnable;
{
VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
0u, // uint32_t compareMask;
0u, // uint32_t writeMask;
0u, // uint32_t reference;
},
{
VK_STENCIL_OP_KEEP, // VkStencilOp failOp;
VK_STENCIL_OP_KEEP, // VkStencilOp passOp;
VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp;
VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
0u, // uint32_t compareMask;
0u, // uint32_t writeMask;
0u, // uint32_t reference;
},
0.0f, // float minDepthBounds;
1.0f, // float maxDepthBounds;
};
const VkPipelineColorBlendAttachmentState colorBlendAttState[]=
{
{
VK_FALSE, // VkBool32 blendEnable;
VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, // VkColorComponentFlags colorWriteMask;
}
};
const VkPipelineColorBlendStateCreateInfo colorBlendState =
{
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
VK_FALSE, // VkBool32 logicOpEnable;
VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
DE_LENGTH_OF_ARRAY(colorBlendAttState), // uint32_t attachmentCount;
colorBlendAttState, // const VkPipelineColorBlendAttachmentState* pAttachments;
{ 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
};
const VkGraphicsPipelineCreateInfo pipelineCreateInfo =
{
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
DE_LENGTH_OF_ARRAY(stages), // uint32_t stageCount;
stages, // const VkPipelineShaderStageCreateInfo* pStages;
&vertexInputState, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
&inputAssemblyState, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
&viewportState, // const VkPipelineViewportStateCreateInfo* pViewportState;
&rasterState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
&multisampleState, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
&depthStencilState, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
&colorBlendState, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
(const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
*res.layout.object, // VkPipelineLayout layout;
*res.renderPass.object, // VkRenderPass renderPass;
0u, // uint32_t subpass;
(VkPipeline)0, // VkPipeline basePipelineHandle;
0, // int32_t basePipelineIndex;
};
return createGraphicsPipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
}
};
struct ComputePipeline
{
typedef VkPipeline Type;
struct Parameters
{
Parameters (void) {}
};
struct Resources
{
Dependency<ShaderModule> shaderModule;
Dependency<PipelineLayout> layout;
Dependency<PipelineCache> pipelineCache;
static DescriptorSetLayout::Parameters getDescriptorSetLayout (void)
{
typedef DescriptorSetLayout::Parameters::Binding Binding;
std::vector<Binding> bindings;
bindings.push_back(Binding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
bindings.push_back(Binding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
return DescriptorSetLayout::Parameters(bindings);
}
Resources (const Environment& env, const Parameters&)
: shaderModule (env, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"))
, layout (env, PipelineLayout::Parameters::singleDescriptorSet(getDescriptorSetLayout()))
, pipelineCache (env, PipelineCache::Parameters())
{}
};
static void initPrograms (SourceCollections& dst, Parameters)
{
ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"));
}
static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkComputePipelineCreateInfo pipelineCreateInfo =
{
VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
{
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
*res.shaderModule.object, // VkShaderModule module;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
},
*res.layout.object, // VkPipelineLayout layout;
(VkPipeline)0, // VkPipeline basePipelineHandle;
0u, // int32_t basePipelineIndex;
};
return createComputePipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineCreateInfo);
}
};
struct DescriptorPool
{
typedef VkDescriptorPool Type;
struct Parameters
{
VkDescriptorPoolCreateFlags flags;
deUint32 maxSets;
std::vector<VkDescriptorPoolSize> poolSizes;
Parameters (VkDescriptorPoolCreateFlags flags_,
deUint32 maxSets_,
const std::vector<VkDescriptorPoolSize>& poolSizes_)
: flags (flags_)
, maxSets (maxSets_)
, poolSizes (poolSizes_)
{}
static Parameters singleType (VkDescriptorPoolCreateFlags flags,
deUint32 maxSets,
VkDescriptorType type,
deUint32 count)
{
std::vector<VkDescriptorPoolSize> poolSizes;
poolSizes.push_back(makeDescriptorPoolSize(type, count));
return Parameters(flags, maxSets, poolSizes);
}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkDescriptorPool> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkDescriptorPoolCreateFlags flags;
params.maxSets, // uint32_t maxSets;
(deUint32)params.poolSizes.size(), // uint32_t poolSizeCount;
(params.poolSizes.empty() ? DE_NULL : &params.poolSizes[0]), // const VkDescriptorPoolSize* pPoolSizes;
};
return createDescriptorPool(env.vkd, env.device, &descriptorPoolCreateInfo);
}
};
struct DescriptorSet
{
typedef VkDescriptorSet Type;
struct Parameters
{
DescriptorSetLayout::Parameters descriptorSetLayout;
Parameters (const DescriptorSetLayout::Parameters& descriptorSetLayout_)
: descriptorSetLayout(descriptorSetLayout_)
{}
};
struct Resources
{
Dependency<DescriptorPool> descriptorPool;
Dependency<DescriptorSetLayout> descriptorSetLayout;
static std::vector<VkDescriptorPoolSize> computePoolSizes (const DescriptorSetLayout::Parameters& layout, int maxSets)
{
deUint32 countByType[VK_DESCRIPTOR_TYPE_LAST];
std::vector<VkDescriptorPoolSize> typeCounts;
std::fill(DE_ARRAY_BEGIN(countByType), DE_ARRAY_END(countByType), 0u);
for (std::vector<DescriptorSetLayout::Parameters::Binding>::const_iterator cur = layout.bindings.begin(); cur != layout.bindings.end(); cur++)
{
DE_ASSERT((deUint32)cur->descriptorType < VK_DESCRIPTOR_TYPE_LAST);
countByType[cur->descriptorType] += cur->descriptorCount * maxSets;
}
for (deUint32 type = 0; type < VK_DESCRIPTOR_TYPE_LAST; type++)
{
if (countByType[type] > 0)
typeCounts.push_back(makeDescriptorPoolSize((VkDescriptorType)type, countByType[type]));
}
return typeCounts;
}
Resources (const Environment& env, const Parameters& params)
: descriptorPool (env, DescriptorPool::Parameters(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u, computePoolSizes(params.descriptorSetLayout, 1u)))
, descriptorSetLayout (env, params.descriptorSetLayout)
{
}
};
static Move<VkDescriptorSet> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkDescriptorSetAllocateInfo allocateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
*res.descriptorPool.object, // VkDescriptorPool descriptorPool;
1u, // uint32_t descriptorSetCount;
&(*res.descriptorSetLayout.object), // const VkDescriptorSetLayout* pSetLayouts;
};
return allocateDescriptorSet(env.vkd, env.device, &allocateInfo);
}
};
struct Framebuffer
{
typedef VkFramebuffer Type;
struct Parameters
{
Parameters (void)
{}
};
struct Resources
{
Dependency<ImageView> colorAttachment;
Dependency<ImageView> depthStencilAttachment;
Dependency<RenderPass> renderPass;
Resources (const Environment& env, const Parameters&)
: colorAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
makeExtent3D(256, 256, 1),
1u, 1u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
VK_IMAGE_LAYOUT_UNDEFINED),
VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)))
, depthStencilAttachment (env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM,
makeExtent3D(256, 256, 1),
1u, 1u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
VK_IMAGE_LAYOUT_UNDEFINED),
VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u)))
, renderPass (env, RenderPass::Parameters())
{}
};
static Move<VkFramebuffer> create (const Environment& env, const Resources& res, const Parameters&)
{
const VkImageView attachments[] =
{
*res.colorAttachment.object,
*res.depthStencilAttachment.object,
};
const VkFramebufferCreateInfo framebufferCreateInfo =
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
*res.renderPass.object, // VkRenderPass renderPass;
(deUint32)DE_LENGTH_OF_ARRAY(attachments), // uint32_t attachmentCount;
attachments, // const VkImageView* pAttachments;
256u, // uint32_t width;
256u, // uint32_t height;
1u, // uint32_t layers;
};
return createFramebuffer(env.vkd, env.device, &framebufferCreateInfo);
}
};
struct CommandPool
{
typedef VkCommandPool Type;
struct Parameters
{
VkCommandPoolCreateFlags flags;
Parameters (VkCommandPoolCreateFlags flags_)
: flags(flags_)
{}
};
struct Resources
{
Resources (const Environment&, const Parameters&) {}
};
static Move<VkCommandPool> create (const Environment& env, const Resources&, const Parameters& params)
{
const VkCommandPoolCreateInfo commandPoolCreateInfo =
{
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
params.flags, // VkCommandPoolCreateFlags flags;
env.queueFamilyIndex, // uint32_t queueFamilyIndex;
};
return createCommandPool(env.vkd, env.device, &commandPoolCreateInfo);
}
};
struct CommandBuffer
{
typedef VkCommandBuffer Type;
struct Parameters
{
CommandPool::Parameters commandPool;
VkCommandBufferLevel level;
Parameters (const CommandPool::Parameters& commandPool_,
VkCommandBufferLevel level_)
: commandPool (commandPool_)
, level (level_)
{}
};
struct Resources
{
Dependency<CommandPool> commandPool;
Resources (const Environment& env, const Parameters& params)
: commandPool(env, params.commandPool)
{}
};
static Move<VkCommandBuffer> create (const Environment& env, const Resources& res, const Parameters& params)
{
const VkCommandBufferAllocateInfo allocateInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
*res.commandPool.object, // VkCommandPool commandPool;
params.level, // VkCommandBufferLevel level;
1, // uint32_t commandBufferCount;
};
return allocateCommandBuffer(env.vkd, env.device, &allocateInfo);
}
};
template<typename Object>
struct NamedParameters
{
const char* name;
typename Object::Parameters parameters;
};
template<typename Object>
struct CaseDescription
{
typename FunctionInstance1<typename Object::Parameters>::Function function;
const NamedParameters<Object>* paramsBegin;
const NamedParameters<Object>* paramsEnd;
};
#define CASE_DESC(FUNCTION, CASES) \
{ FUNCTION, DE_ARRAY_BEGIN(CASES), DE_ARRAY_END(CASES) }
struct CaseDescriptions
{
CaseDescription<Device> device;
CaseDescription<DeviceMemory> deviceMemory;
CaseDescription<Buffer> buffer;
CaseDescription<BufferView> bufferView;
CaseDescription<Image> image;
CaseDescription<ImageView> imageView;
CaseDescription<Semaphore> semaphore;
CaseDescription<Event> event;
CaseDescription<Fence> fence;
CaseDescription<QueryPool> queryPool;
CaseDescription<ShaderModule> shaderModule;
CaseDescription<PipelineCache> pipelineCache;
CaseDescription<Sampler> sampler;
CaseDescription<DescriptorSetLayout> descriptorSetLayout;
CaseDescription<PipelineLayout> pipelineLayout;
CaseDescription<RenderPass> renderPass;
CaseDescription<GraphicsPipeline> graphicsPipeline;
CaseDescription<ComputePipeline> computePipeline;
CaseDescription<DescriptorPool> descriptorPool;
CaseDescription<DescriptorSet> descriptorSet;
CaseDescription<Framebuffer> framebuffer;
CaseDescription<CommandPool> commandPool;
CaseDescription<CommandBuffer> commandBuffer;
};
template<typename Object>
static void checkSupport (Context& context, typename Object::Parameters)
{
context.requireDeviceFunctionality("VK_EXT_device_memory_report");
}
template<typename Object>
void addCases (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
{
for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
{
addFunctionCase(group.get(), cur->name, "", checkSupport<Object>, cases.function, cur->parameters);
}
}
template<typename Object>
void addCasesWithProgs (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
{
for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; cur++)
{
addFunctionCaseWithPrograms(group.get(), cur->name, "", checkSupport<Object>, Object::initPrograms, cases.function, cur->parameters);
}
}
tcu::TestCaseGroup* createObjectTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc, const CaseDescriptions& cases)
{
MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
addCases (group, cases.device);
addCases (group, cases.deviceMemory);
addCases (group, cases.buffer);
addCases (group, cases.bufferView);
addCases (group, cases.image);
addCases (group, cases.imageView);
addCases (group, cases.semaphore);
addCases (group, cases.event);
addCases (group, cases.fence);
addCases (group, cases.queryPool);
addCasesWithProgs (group, cases.shaderModule);
addCases (group, cases.pipelineCache);
addCases (group, cases.sampler);
addCases (group, cases.descriptorSetLayout);
addCases (group, cases.pipelineLayout);
addCases (group, cases.renderPass);
addCasesWithProgs (group, cases.graphicsPipeline);
addCasesWithProgs (group, cases.computePipeline);
addCases (group, cases.descriptorPool);
addCases (group, cases.descriptorSet);
addCases (group, cases.framebuffer);
addCases (group, cases.commandPool);
addCases (group, cases.commandBuffer);
return group.release();
}
static deBool validateCallbackRecords (Context& context, const CallbackRecorder& recorder)
{
tcu::TestLog& log = context.getTestContext().getLog();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
const InstanceInterface& vki = context.getInstanceInterface();
const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
std::set<std::pair<deUint64, deUint64>> memoryObjectSet;
for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
{
const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
if ((record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT) &&
record.heapIndex >= memoryProperties.memoryHeapCount)
{
log << tcu::TestLog::Message << "memoryHeapCount: " << memoryProperties.memoryHeapCount << tcu::TestLog::EndMessage;
log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
return false;
}
if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT)
{
log << tcu::TestLog::Message << "Observed ALLOCATION_FAILED event" << tcu::TestLog::EndMessage;
log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
continue;
}
if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT ||
record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
{
memoryObjectSet.insert(std::make_pair(record.memoryObjectId, record.objectHandle));
continue;
}
if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT ||
record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
{
const auto objectPair = std::make_pair(record.memoryObjectId, record.objectHandle);
if (!memoryObjectSet.count(objectPair))
{
log << tcu::TestLog::Message << "Unpaired or out-of-order free/unimport event" << tcu::TestLog::EndMessage;
log << tcu::TestLog::Message << record << tcu::TestLog::EndMessage;
return false;
}
memoryObjectSet.erase(objectPair);
}
}
if (!memoryObjectSet.empty())
{
log << tcu::TestLog::Message << "Unpaired alloc/import event" << tcu::TestLog::EndMessage;
return false;
}
return true;
}
struct EnvClone
{
Unique<VkDevice> device;
DeviceDriver vkd;
Environment env;
EnvClone (const Environment& parent)
: device (Device::create(parent, Device::Resources(parent, Device::Parameters()), Device::Parameters()))
, vkd (parent.vkp, parent.instance, *device)
, env (parent.vkp, parent.vki, parent.instance, parent.physicalDevice, vkd, *device, parent.queueFamilyIndex, parent.programBinaries, parent.commandLine, nullptr)
{
}
};
template<typename Object>
tcu::TestStatus createDestroyObjectTest (Context& context, typename Object::Parameters params)
{
CallbackRecorder recorder;
const Environment env (context.getPlatformInterface(),
context.getInstanceInterface(),
context.getInstance(),
context.getPhysicalDevice(),
context.getDeviceInterface(),
context.getDevice(),
context.getUniversalQueueFamilyIndex(),
context.getBinaryCollection(),
context.getTestContext().getCommandLine(),
&recorder);
if (std::is_same<Object, Device>::value)
{
const typename Object::Resources res (env, params);
Unique<typename Object::Type> obj (Object::create(env, res, params));
}
else
{
const EnvClone envWithCustomDevice (env);
const typename Object::Resources res (envWithCustomDevice.env, params);
Unique<typename Object::Type> obj (Object::create(envWithCustomDevice.env, res, params));
}
if (!validateCallbackRecords(context, recorder))
{
return tcu::TestStatus::fail("Invalid device memory report callback");
}
return tcu::TestStatus::pass("Ok");
}
tcu::TestStatus vkDeviceMemoryAllocateAndFreeTest (Context& context)
{
CallbackRecorder recorder;
const PlatformInterface& vkp = context.getPlatformInterface();
const VkInstance instance = context.getInstance();
const InstanceInterface& vki = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const deBool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
const Unique<VkDevice> device (createDeviceWithMemoryReport(isValidationEnabled, vkp, instance, vki, physicalDevice, queueFamilyIndex, &recorder));
const DeviceDriver vkd (vkp, instance, *device);
const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
const VkDeviceSize testSize = 1024;
const deUint32 testTypeIndex = 0;
const deUint32 testHeapIndex = memoryProperties.memoryTypes[testTypeIndex].heapIndex;
deUint64 objectHandle = 0;
{
recorder.setCallbackMarker(MARKER_ALLOCATE);
VkResult result = VK_SUCCESS;
VkDeviceMemory memory = DE_NULL;
const VkMemoryAllocateInfo memoryAllocateInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
testSize, // VkDeviceSize allocationSize;
testHeapIndex, // uint32_t memoryTypeIndex;
};
result = vkd.allocateMemory(*device, &memoryAllocateInfo, (const VkAllocationCallbacks*)DE_NULL, &memory);
if (result != VK_SUCCESS)
{
return tcu::TestStatus::fail("Unable to allocate " + de::toString(testSize) + " bytes of memory");
}
objectHandle = memory.getInternal();
recorder.setCallbackMarker(MARKER_FREE);
vkd.freeMemory(*device, memory, (const VkAllocationCallbacks*)DE_NULL);
}
recorder.setCallbackMarker(MARKER_UNKNOWN);
deBool allocateEvent = false;
deBool freeEvent = false;
deUint64 memoryObjectId = 0;
for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
{
const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
const CallbackMarker marker = iter->second;
if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
{
TCU_CHECK(marker == MARKER_ALLOCATE);
TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
TCU_CHECK(memoryObjectId == 0);
TCU_CHECK(record.memoryObjectId != 0);
TCU_CHECK_MSG(record.size >= testSize, ("record.size=" + de::toString(record.size) + ", testSize=" + de::toString(testSize)).c_str());
TCU_CHECK(record.heapIndex == testHeapIndex);
memoryObjectId = record.memoryObjectId;
allocateEvent = true;
}
else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
{
TCU_CHECK(marker == MARKER_FREE);
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("record.memoryObjectId=" + de::toString(record.memoryObjectId) +
", memoryObjectId=" + de::toString(memoryObjectId)).c_str());
freeEvent = true;
}
}
TCU_CHECK(allocateEvent);
TCU_CHECK(freeEvent);
return tcu::TestStatus::pass("Ok");
}
tcu::TestStatus vkDeviceMemoryAllocationFailedTest (Context& context)
{
CallbackRecorder recorder;
const PlatformInterface& vkp = context.getPlatformInterface();
const VkInstance instance = context.getInstance();
const InstanceInterface& vki = context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const deBool isValidationEnabled = context.getTestContext().getCommandLine().isValidationEnabled();
const Unique<VkDevice> device (createDeviceWithMemoryReport(isValidationEnabled, vkp, instance, vki, physicalDevice, queueFamilyIndex, &recorder));
const DeviceDriver vkd (vkp, instance, *device);
const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physicalDevice);
const VkDeviceSize testSize = std::numeric_limits<deUint64>::max();
const deUint32 testTypeIndex = 0;
const deUint32 testHeapIndex = memoryProperties.memoryTypes[testTypeIndex].heapIndex;
{
recorder.setCallbackMarker(MARKER_ALLOCATION_FAILED);
VkResult result = VK_SUCCESS;
VkDeviceMemory memory = DE_NULL;
const VkMemoryAllocateInfo memoryAllocateInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
testSize, // VkDeviceSize allocationSize;
testHeapIndex, // uint32_t memoryTypeIndex;
};
result = vkd.allocateMemory(*device, &memoryAllocateInfo, (const VkAllocationCallbacks*)DE_NULL, &memory);
if (result == VK_SUCCESS)
{
return tcu::TestStatus::fail("Should not be able to allocate UINT64_MAX bytes of memory");
}
recorder.setCallbackMarker(MARKER_UNKNOWN);
}
deBool allocationFailedEvent = false;
for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
{
const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
const CallbackMarker marker = iter->second;
if (record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT)
{
TCU_CHECK(marker == MARKER_ALLOCATION_FAILED);
TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
TCU_CHECK_MSG(record.size >= testSize, ("record.size=" + de::toString(record.size) + ", testSize=" + de::toString(testSize)).c_str());
TCU_CHECK(record.heapIndex == testHeapIndex);
allocationFailedEvent = true;
}
}
TCU_CHECK(allocationFailedEvent);
return tcu::TestStatus::pass("Ok");
}
static void checkSupport (Context& context)
{
context.requireDeviceFunctionality("VK_EXT_device_memory_report");
}
tcu::TestCaseGroup* createVkDeviceMemoryTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc)
{
MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
addFunctionCase(group.get(), "allocate_and_free", "", checkSupport, vkDeviceMemoryAllocateAndFreeTest);
addFunctionCase(group.get(), "allocation_failed", "", checkSupport, vkDeviceMemoryAllocationFailedTest);
return group.release();
}
static void checkSupport (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
{
context.requireInstanceFunctionality("VK_KHR_external_memory_capabilities");
context.requireDeviceFunctionality("VK_EXT_device_memory_report");
context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
{
context.requireDeviceFunctionality("VK_KHR_external_memory_fd");
}
if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
{
context.requireDeviceFunctionality("VK_EXT_external_memory_dma_buf");
}
if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
{
context.requireDeviceFunctionality("VK_KHR_external_memory_win32");
}
if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
{
context.requireDeviceFunctionality("VK_ANDROID_external_memory_android_hardware_buffer");
}
}
static std::vector<std::string> getInstanceExtensions (const deUint32 instanceVersion)
{
std::vector<std::string> instanceExtensions;
if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_get_physical_device_properties2"))
instanceExtensions.push_back("VK_KHR_get_physical_device_properties2");
if (!isCoreInstanceExtension(instanceVersion, "VK_KHR_external_memory_capabilities"))
instanceExtensions.push_back("VK_KHR_external_memory_capabilities");
return instanceExtensions;
}
static Move<VkDevice> createExternalMemoryDevice (deBool isValidationEnabled,
const PlatformInterface& vkp,
VkInstance instance,
const InstanceInterface& vki,
VkPhysicalDevice physicalDevice,
deUint32 apiVersion,
deUint32 queueFamilyIndex,
VkExternalMemoryHandleTypeFlagBits externalMemoryType,
const CallbackRecorder* recorder)
{
const deUint32 queueCount = 1;
const float queuePriority = 1.0f;
std::vector<const char*> enabledExtensions = {"VK_EXT_device_memory_report"};
if (!isCoreDeviceExtension(apiVersion, "VK_KHR_dedicated_allocation"))
{
enabledExtensions.push_back("VK_KHR_dedicated_allocation");
}
if (!isCoreDeviceExtension(apiVersion, "VK_KHR_get_memory_requirements2"))
{
enabledExtensions.push_back("VK_KHR_get_memory_requirements2");
}
if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))
{
if (!isCoreDeviceExtension(apiVersion, "VK_KHR_external_memory_fd"))
{
enabledExtensions.push_back("VK_KHR_external_memory_fd");
}
}
if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)
{
enabledExtensions.push_back("VK_EXT_external_memory_dma_buf");
}
if (externalMemoryType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT |
VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT))
{
enabledExtensions.push_back("VK_KHR_external_memory_win32");
}
if (externalMemoryType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
{
enabledExtensions.push_back("VK_ANDROID_external_memory_android_hardware_buffer");
enabledExtensions.push_back("VK_EXT_queue_family_foreign");
if (!isCoreDeviceExtension(apiVersion, "VK_KHR_sampler_ycbcr_conversion"))
{
enabledExtensions.push_back("VK_KHR_sampler_ycbcr_conversion");
}
}
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceMemoryReportFeatures =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, // VkStructureType sType;
DE_NULL, // void* pNext;
VK_TRUE // VkBool32 deviceMemoryReport;
};
const VkDeviceDeviceMemoryReportCreateInfoEXT deviceMemoryReportCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, // VkStructureType sType;
&deviceMemoryReportFeatures, // void* pNext;
(VkDeviceMemoryReportFlagsEXT)0, // VkDeviceMemoryReportFlagsEXT flags;
recorder->callback, // PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
(void*)recorder, // void* pUserData;
};
const VkDeviceQueueCreateInfo queueCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkDeviceQueueCreateFlags)0, // VkDeviceQueueCreateFlags flags;
queueFamilyIndex, // deUint32 queueFamilyIndex;
queueCount, // deUint32 queueCount;
&queuePriority, // const float* pQueuePriorities;
};
const VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType;
&deviceMemoryReportCreateInfo, // const void* pNext;
(VkDeviceCreateFlags)0, // VkDeviceCreateFlags flags;
queueCount, // uint32_t queueCreateInfoCount;
&queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
0u, // uint32_t enabledLayerCount;
DE_NULL, // const char* const* ppEnabledLayerNames;
(deUint32)enabledExtensions.size(), // uint32_t enabledExtensionCount;
enabledExtensions.data(), // const char* const* ppEnabledExtensionNames;
DE_NULL, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
return createCustomDevice(isValidationEnabled, vkp, instance, vki, physicalDevice, &deviceCreateInfo);
}
static void checkBufferSupport (const InstanceInterface& vki,
VkPhysicalDevice device,
VkBufferUsageFlags usage,
VkExternalMemoryHandleTypeFlagBits externalMemoryType)
{
const VkPhysicalDeviceExternalBufferInfo info =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, // VkStructureType sType;
DE_NULL, // void* pNext;
(VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
usage, // VkBufferUsageFlags usage;
externalMemoryType, // VkExternalMemoryHandleTypeFlagBits handleType;
};
VkExternalBufferProperties properties =
{
VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, // VkStructureType sType;
DE_NULL, // void* pNext;
{ 0u, 0u, 0u }, // VkExternalMemoryProperties externalMemoryProperties;
};
vki.getPhysicalDeviceExternalBufferProperties(device, &info, &properties);
if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support exporting buffer");
if ((properties.externalMemoryProperties.externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support importing buffer");
}
tcu::TestStatus testImportAndUnimportExternalMemory (Context& context, VkExternalMemoryHandleTypeFlagBits externalMemoryType)
{
CallbackRecorder recorder;
const PlatformInterface& vkp (context.getPlatformInterface());
const CustomInstance instance (createCustomInstanceWithExtensions(context, getInstanceExtensions(context.getUsedApiVersion())));
const InstanceDriver& vki (instance.getDriver());
const VkPhysicalDevice physicalDevice (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (context.getUniversalQueueFamilyIndex());
const Unique<VkDevice> device (createExternalMemoryDevice(context.getTestContext().getCommandLine().isValidationEnabled(),
vkp,
instance,
vki,
physicalDevice,
context.getUsedApiVersion(),
queueFamilyIndex,
externalMemoryType,
&recorder));
const DeviceDriver vkd (vkp, instance, *device);
const VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
const VkDeviceSize bufferSize = 1024;
checkBufferSupport(vki, physicalDevice, usage, externalMemoryType);
const Unique<VkBuffer> buffer (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
const VkMemoryRequirements requirements (getBufferMemoryRequirements(vkd, *device, *buffer));
const deUint32 memoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
deUint64 objectHandle = 0;
deUint64 objectHandleA = 0;
deUint64 objectHandleB = 0;
{
recorder.setCallbackMarker(MARKER_ALLOCATE);
const Unique<VkDeviceMemory> memory (allocateExportableMemory(vkd, *device, requirements.size, memoryTypeIndex, externalMemoryType, *buffer));
objectHandle = (*memory).getInternal();
NativeHandle handleA;
getMemoryNative(vkd, *device, *memory, externalMemoryType, handleA);
NativeHandle handleB (handleA);
const Unique<VkBuffer> bufferA (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
const Unique<VkBuffer> bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, externalMemoryType, bufferSize, 0u, usage));
{
recorder.setCallbackMarker(MARKER_IMPORT);
const Unique<VkDeviceMemory> memoryA (importDedicatedMemory(vkd, *device, *bufferA, requirements, externalMemoryType, memoryTypeIndex, handleA));
const Unique<VkDeviceMemory> memoryB (importDedicatedMemory(vkd, *device, *bufferB, requirements, externalMemoryType, memoryTypeIndex, handleB));
objectHandleA = (*memoryA).getInternal();
objectHandleB = (*memoryB).getInternal();
recorder.setCallbackMarker(MARKER_UNIMPORT);
}
recorder.setCallbackMarker(MARKER_FREE);
}
recorder.setCallbackMarker(MARKER_UNKNOWN);
deBool allocateEvent = false;
deBool freeEvent = false;
deBool importA = false;
deBool importB = false;
deBool unimportA = false;
deBool unimportB = false;
deUint64 memoryObjectId = 0;
for (auto iter = recorder.getRecordsBegin(); iter != recorder.getRecordsEnd(); iter++)
{
const VkDeviceMemoryReportCallbackDataEXT& record = iter->first;
const CallbackMarker marker = iter->second;
if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT)
{
TCU_CHECK(marker == MARKER_ALLOCATE);
TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
TCU_CHECK(memoryObjectId == 0);
TCU_CHECK(record.memoryObjectId != 0);
TCU_CHECK_MSG(record.size >= requirements.size,
("size: record=" + de::toString(record.size) +
", requirements=" + de::toString(requirements.size)).c_str());
allocateEvent = true;
memoryObjectId = record.memoryObjectId;
}
else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
{
TCU_CHECK(marker == MARKER_IMPORT);
TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
TCU_CHECK_MSG(record.size >= requirements.size,
("sizeA: record=" + de::toString(record.size) +
", requirements=" + de::toString(requirements.size)).c_str());
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
", original=" + de::toString(memoryObjectId)).c_str());
importA = true;
}
else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT)
{
TCU_CHECK(marker == MARKER_IMPORT);
TCU_CHECK(record.objectType == VK_OBJECT_TYPE_DEVICE_MEMORY);
TCU_CHECK_MSG(record.size >= requirements.size,
("sizeB: record=" + de::toString(record.size) +
", requirements=" + de::toString(requirements.size)).c_str());
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
", original=" + de::toString(memoryObjectId)).c_str());
importB = true;
}
else if (record.objectHandle == objectHandleB && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
{
TCU_CHECK(marker == MARKER_UNIMPORT);
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("memoryObjectIdA: record=" + de::toString(record.memoryObjectId) +
", original=" + de::toString(memoryObjectId)).c_str());
unimportB = true;
}
else if (record.objectHandle == objectHandleA && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT)
{
TCU_CHECK(marker == MARKER_UNIMPORT);
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("memoryObjectIdB: record=" + de::toString(record.memoryObjectId) +
", original=" + de::toString(memoryObjectId)).c_str());
unimportA = true;
}
else if (record.objectHandle == objectHandle && record.type == VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT)
{
TCU_CHECK(marker == MARKER_FREE);
TCU_CHECK_MSG(record.memoryObjectId == memoryObjectId,
("memoryObjectId: record=" + de::toString(record.memoryObjectId) +
", original=" + de::toString(memoryObjectId)).c_str());
freeEvent = true;
}
}
TCU_CHECK(allocateEvent);
TCU_CHECK(importA);
TCU_CHECK(importB);
TCU_CHECK(unimportB);
TCU_CHECK(unimportA);
TCU_CHECK(freeEvent);
return tcu::TestStatus::pass("Pass");
}
tcu::TestCaseGroup* createExternalMemoryTestsGroup (tcu::TestContext& testCtx, const char* name, const char* desc)
{
MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, name, desc));
const std::vector<VkExternalMemoryHandleTypeFlagBits> externalMemoryTypes =
{
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
};
for (const auto externalMemoryType : externalMemoryTypes)
{
const std::string testName = std::string("import_and_unimport_") + std::string(externalMemoryTypeToName(externalMemoryType));
addFunctionCase(group.get(), testName.c_str(), "", checkSupport, testImportAndUnimportExternalMemory, externalMemoryType);
}
return group.release();
}
} // anonymous
tcu::TestCaseGroup* createDeviceMemoryReportTests (tcu::TestContext& testCtx)
{
MovePtr<tcu::TestCaseGroup> deviceMemoryReportTests (new tcu::TestCaseGroup(testCtx, "device_memory_report", "Device Memory Report tests"));
const Image::Parameters img1D (0u,
VK_IMAGE_TYPE_1D,
VK_FORMAT_R8G8B8A8_UNORM,
makeExtent3D(256, 1, 1),
1u,
4u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT,
VK_IMAGE_LAYOUT_UNDEFINED);
const Image::Parameters img2D (0u,
VK_IMAGE_TYPE_2D,
VK_FORMAT_R8G8B8A8_UNORM,
makeExtent3D(64, 64, 1),
1u,
12u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
VK_IMAGE_LAYOUT_UNDEFINED);
const Image::Parameters imgCube (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
VK_IMAGE_TYPE_2D,
VK_FORMAT_R8G8B8A8_UNORM,
makeExtent3D(64, 64, 1),
1u,
12u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
VK_IMAGE_LAYOUT_UNDEFINED);
const Image::Parameters img3D (0u,
VK_IMAGE_TYPE_3D,
VK_FORMAT_R8G8B8A8_UNORM,
makeExtent3D(64, 64, 4),
1u,
1u,
VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT,
VK_IMAGE_LAYOUT_UNDEFINED);
const ImageView::Parameters imgView1D (img1D,
VK_IMAGE_VIEW_TYPE_1D,
img1D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
const ImageView::Parameters imgView1DArr (img1D,
VK_IMAGE_VIEW_TYPE_1D_ARRAY,
img1D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 4u));
const ImageView::Parameters imgView2D (img2D,
VK_IMAGE_VIEW_TYPE_2D,
img2D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
const ImageView::Parameters imgView2DArr (img2D,
VK_IMAGE_VIEW_TYPE_2D_ARRAY,
img2D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 8u));
const ImageView::Parameters imgViewCube (imgCube,VK_IMAGE_VIEW_TYPE_CUBE,
img2D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 6u));
const ImageView::Parameters imgViewCubeArr (imgCube,
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
img2D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 12u));
const ImageView::Parameters imgView3D (img3D,
VK_IMAGE_VIEW_TYPE_3D,
img3D.format,
makeComponentMappingRGBA(),
makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
const DescriptorSetLayout::Parameters singleUboDescLayout = DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, VK_SHADER_STAGE_VERTEX_BIT);
const NamedParameters<Device> s_deviceCases[] =
{
{ "device", Device::Parameters() },
};
static const NamedParameters<DeviceMemory> s_deviceMemCases[] =
{
{ "device_memory_small", DeviceMemory::Parameters(1024, 0u) },
};
static const NamedParameters<Buffer> s_bufferCases[] =
{
{ "buffer_uniform_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
{ "buffer_uniform_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), },
{ "buffer_storage_small", Buffer::Parameters(1024u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
{ "buffer_storage_large", Buffer::Parameters(1024u*1024u*16u, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), },
};
static const NamedParameters<BufferView> s_bufferViewCases[] =
{
{ "buffer_view_uniform_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
{ "buffer_view_storage_r8g8b8a8_unorm", BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u) },
};
static const NamedParameters<Image> s_imageCases[] =
{
{ "image_1d", img1D },
{ "image_2d", img2D },
{ "image_3d", img3D },
};
static const NamedParameters<ImageView> s_imageViewCases[] =
{
{ "image_view_1d", imgView1D },
{ "image_view_1d_arr", imgView1DArr },
{ "image_view_2d", imgView2D },
{ "image_view_2d_arr", imgView2DArr },
{ "image_view_cube", imgViewCube },
{ "image_view_cube_arr", imgViewCubeArr },
{ "image_view_3d", imgView3D },
};
static const NamedParameters<Semaphore> s_semaphoreCases[] =
{
{ "semaphore", Semaphore::Parameters(0u), }
};
static const NamedParameters<Event> s_eventCases[] =
{
{ "event", Event::Parameters(0u) }
};
static const NamedParameters<Fence> s_fenceCases[] =
{
{ "fence", Fence::Parameters(0u) },
{ "fence_signaled", Fence::Parameters(VK_FENCE_CREATE_SIGNALED_BIT) }
};
static const NamedParameters<QueryPool> s_queryPoolCases[] =
{
{ "query_pool", QueryPool::Parameters(VK_QUERY_TYPE_OCCLUSION, 1u, 0u) }
};
static const NamedParameters<ShaderModule> s_shaderModuleCases[] =
{
{ "shader_module", ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "test") }
};
static const NamedParameters<PipelineCache> s_pipelineCacheCases[] =
{
{ "pipeline_cache", PipelineCache::Parameters() }
};
static const NamedParameters<Sampler> s_samplerCases[] =
{
{ "sampler", Sampler::Parameters() }
};
static const NamedParameters<DescriptorSetLayout> s_descriptorSetLayoutCases[] =
{
{ "descriptor_set_layout_empty", DescriptorSetLayout::Parameters::empty() },
{ "descriptor_set_layout_single", singleUboDescLayout }
};
static const NamedParameters<PipelineLayout> s_pipelineLayoutCases[] =
{
{ "pipeline_layout_empty", PipelineLayout::Parameters::empty() },
{ "pipeline_layout_single", PipelineLayout::Parameters::singleDescriptorSet(singleUboDescLayout) }
};
static const NamedParameters<RenderPass> s_renderPassCases[] =
{
{ "render_pass", RenderPass::Parameters() }
};
static const NamedParameters<GraphicsPipeline> s_graphicsPipelineCases[] =
{
{ "graphics_pipeline", GraphicsPipeline::Parameters() }
};
static const NamedParameters<ComputePipeline> s_computePipelineCases[] =
{
{ "compute_pipeline", ComputePipeline::Parameters() }
};
static const NamedParameters<DescriptorPool> s_descriptorPoolCases[] =
{
{ "descriptor_pool", DescriptorPool::Parameters::singleType((VkDescriptorPoolCreateFlags)0, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) },
{ "descriptor_pool_free_descriptor_set", DescriptorPool::Parameters::singleType(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u) }
};
static const NamedParameters<DescriptorSet> s_descriptorSetCases[] =
{
{ "descriptor_set", DescriptorSet::Parameters(singleUboDescLayout) }
};
static const NamedParameters<Framebuffer> s_framebufferCases[] =
{
{ "framebuffer", Framebuffer::Parameters() }
};
static const NamedParameters<CommandPool> s_commandPoolCases[] =
{
{ "command_pool", CommandPool::Parameters((VkCommandPoolCreateFlags)0) },
{ "command_pool_transient", CommandPool::Parameters(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) }
};
static const NamedParameters<CommandBuffer> s_commandBufferCases[] =
{
{ "command_buffer_primary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_PRIMARY) },
{ "command_buffer_secondary", CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_SECONDARY) }
};
const CaseDescriptions s_createDestroyObjectGroup =
{
CASE_DESC(createDestroyObjectTest <Device>, s_deviceCases),
CASE_DESC(createDestroyObjectTest <DeviceMemory>, s_deviceMemCases),
CASE_DESC(createDestroyObjectTest <Buffer>, s_bufferCases),
CASE_DESC(createDestroyObjectTest <BufferView>, s_bufferViewCases),
CASE_DESC(createDestroyObjectTest <Image>, s_imageCases),
CASE_DESC(createDestroyObjectTest <ImageView>, s_imageViewCases),
CASE_DESC(createDestroyObjectTest <Semaphore>, s_semaphoreCases),
CASE_DESC(createDestroyObjectTest <Event>, s_eventCases),
CASE_DESC(createDestroyObjectTest <Fence>, s_fenceCases),
CASE_DESC(createDestroyObjectTest <QueryPool>, s_queryPoolCases),
CASE_DESC(createDestroyObjectTest <ShaderModule>, s_shaderModuleCases),
CASE_DESC(createDestroyObjectTest <PipelineCache>, s_pipelineCacheCases),
CASE_DESC(createDestroyObjectTest <Sampler>, s_samplerCases),
CASE_DESC(createDestroyObjectTest <DescriptorSetLayout>, s_descriptorSetLayoutCases),
CASE_DESC(createDestroyObjectTest <PipelineLayout>, s_pipelineLayoutCases),
CASE_DESC(createDestroyObjectTest <RenderPass>, s_renderPassCases),
CASE_DESC(createDestroyObjectTest <GraphicsPipeline>, s_graphicsPipelineCases),
CASE_DESC(createDestroyObjectTest <ComputePipeline>, s_computePipelineCases),
CASE_DESC(createDestroyObjectTest <DescriptorPool>, s_descriptorPoolCases),
CASE_DESC(createDestroyObjectTest <DescriptorSet>, s_descriptorSetCases),
CASE_DESC(createDestroyObjectTest <Framebuffer>, s_framebufferCases),
CASE_DESC(createDestroyObjectTest <CommandPool>, s_commandPoolCases),
CASE_DESC(createDestroyObjectTest <CommandBuffer>, s_commandBufferCases),
};
deviceMemoryReportTests->addChild(createObjectTestsGroup(testCtx, "create_and_destroy_object", "Check emitted callbacks are properly paired", s_createDestroyObjectGroup));
deviceMemoryReportTests->addChild(createVkDeviceMemoryTestsGroup(testCtx, "vk_device_memory", "Check callbacks are emitted properly for VkDeviceMemory"));
deviceMemoryReportTests->addChild(createExternalMemoryTestsGroup(testCtx, "external_memory", "Check callbacks are emitted properly for external memory"));
return deviceMemoryReportTests.release();
}
} // memory
} // vkt