virtual tcu::TestStatus createTestBuffer (VkDeviceSize size,
VkBufferUsageFlags usage,
Context& context,
- Move<VkBuffer>& testBuffer) const = 0;
+ Move<VkBuffer>& testBuffer,
+ Move<VkDeviceMemory>& memory) const = 0;
};
class BufferSuballocation : public IBufferAllocator
virtual tcu::TestStatus createTestBuffer (VkDeviceSize size,
VkBufferUsageFlags usage,
Context& context,
- Move<VkBuffer>& testBuffer) const;
+ Move<VkBuffer>& testBuffer,
+ Move<VkDeviceMemory>& memory) const;
};
class BufferDedicatedAllocation : public IBufferAllocator
virtual tcu::TestStatus createTestBuffer (VkDeviceSize size,
VkBufferUsageFlags usage,
Context& context,
- Move<VkBuffer>& testBuffer) const;
+ Move<VkBuffer>& testBuffer,
+ Move<VkDeviceMemory>& memory) const;
};
class BufferViewTestCase : public TestCase
tcu::TestStatus BufferSuballocation::createTestBuffer (VkDeviceSize size,
VkBufferUsageFlags usage,
Context& context,
- Move<VkBuffer>& testBuffer) const
+ Move<VkBuffer>& testBuffer,
+ Move<VkDeviceMemory>& memory) const
{
const VkDevice vkDevice = context.getDevice();
const DeviceInterface& vk = context.getDeviceInterface();
return tcu::TestStatus::fail(errorMsg.str());
}
- Move<VkDeviceMemory> memory;
const VkMemoryAllocateInfo memAlloc =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType
tcu::TestStatus BufferDedicatedAllocation::createTestBuffer (VkDeviceSize size,
VkBufferUsageFlags usage,
Context& context,
- Move<VkBuffer>& testBuffer) const
+ Move<VkBuffer>& testBuffer,
+ Move<VkDeviceMemory>& memory) const
{
const std::vector<std::string>& extensions = context.getDeviceExtensions();
const deBool isSupported = std::find(extensions.begin(), extensions.end(), "VK_KHR_dedicated_allocation") != extensions.end();
//const VkMemoryType memoryType = memoryProperties.memoryTypes[heapTypeIndex];
//const VkMemoryHeap memoryHeap = memoryProperties.memoryHeaps[memoryType.heapIndex];
- Move<VkDeviceMemory> memory;
vk.getBufferMemoryRequirements2KHR(vkDevice, &info, &memReqs); // get the proper size requirement
if (size > memReqs.memoryRequirements.size)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDeviceSize size = 3 * 5 * 7 * 64;
Move<VkBuffer> testBuffer;
+ Move<VkDeviceMemory> testBufferMemory;
VkFormatProperties properties;
m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), m_testCase.format, &properties);
// Create buffer
if (m_testCase.bufferAllocationKind == ALLOCATION_KIND_DEDICATED)
{
- BufferDedicatedAllocation().createTestBuffer(size, m_testCase.usage, m_context, testBuffer);
+ BufferDedicatedAllocation().createTestBuffer(size, m_testCase.usage, m_context, testBuffer, testBufferMemory);
}
else
{
- BufferSuballocation().createTestBuffer(size, m_testCase.usage, m_context, testBuffer);
+ BufferSuballocation().createTestBuffer(size, m_testCase.usage, m_context, testBuffer, testBufferMemory);
}
{
case FILL_MODE_RED:
if (tcu::isCombinedDepthStencilType(buffer.getFormat().type))
{
- buffer.setPixDepth(redColor[x % 4], x, y, z);
+ buffer.setPixDepth(redColor[0], x, y, z);
if (tcu::hasStencilComponent(buffer.getFormat().order))
- buffer.setPixStencil(255 * (int)redColor[y % 4], x, y, z);
+ buffer.setPixStencil((int)redColor[3], x, y, z);
}
else
buffer.setPixel(redColor, x, y, z);
deUint32 x=a;
deUint32 y=b;
- while (x%b != 0)
+ while (x%y != 0)
{
temp = y;
y = x%y;
DE_ASSERT((bufferMemRequirement.size % bufferMemRequirement.alignment) == 0);
- std::vector<DeviceMemorySp> deviceMemUniquePtrVec;
+ Move<VkDeviceMemory> sparseMemoryAllocation;
{
std::vector<VkSparseMemoryBind> sparseMemoryBinds;
const deUint32 numSparseBinds = static_cast<deUint32>(bufferMemRequirement.size / bufferMemRequirement.alignment);
- const deUint32 memoryType = findMatchingMemoryType(instance, physicalDevice, bufferMemRequirement, MemoryRequirement::Any);
+ const deUint32 memoryType = findMatchingMemoryType(instance, physicalDevice, bufferMemRequirement, MemoryRequirement::Any);
if (memoryType == NO_MATCH_FOUND)
return tcu::TestStatus::fail("No matching memory type found");
- for (deUint32 sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
{
- const VkSparseMemoryBind sparseMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(), bufferMemRequirement.alignment, memoryType, bufferMemRequirement.alignment * sparseBindNdx);
+ const VkMemoryAllocateInfo allocateInfo =
+ {
+ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ bufferMemRequirement.size, // VkDeviceSize allocationSize;
+ memoryType, // uint32_t memoryTypeIndex;
+ };
+
+ sparseMemoryAllocation = allocateMemory(deviceInterface, getDevice(), &allocateInfo);
+ }
- deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(sparseMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
+ for (deUint32 sparseBindNdx = 0; sparseBindNdx < numSparseBinds; ++sparseBindNdx)
+ {
+ const VkSparseMemoryBind sparseMemoryBind =
+ {
+ bufferMemRequirement.alignment * sparseBindNdx, // VkDeviceSize resourceOffset;
+ bufferMemRequirement.alignment, // VkDeviceSize size;
+ *sparseMemoryAllocation, // VkDeviceMemory memory;
+ bufferMemRequirement.alignment * sparseBindNdx, // VkDeviceSize memoryOffset;
+ (VkSparseMemoryBindFlags)0, // VkSparseMemoryBindFlags flags;
+ };
sparseMemoryBinds.push_back(sparseMemoryBind);
}
useStorageBuffer ? "opatomic_storage_buffer" : "opatomic",
"Test the OpAtomic* opcodes"));
de::Random rnd (deStringHash(group->getName()));
- const int numElements = 1000000;
+ const int numElements = 65535;
vector<OpAtomicCase> cases;
const StringTemplate shaderTemplate (
if (!dedicated && dedicatedRequirements.requiresDedicatedAllocation)
TCU_THROW(NotSupportedError, "Memory requires dedicated allocation");
+
+ memoryRequirements = requirements.memoryRequirements;
}
else
{
, m_physicalDeviceA (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine()))
, m_queueFamiliesA (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA))
, m_queueFamilyIndicesA (getFamilyIndices(m_queueFamiliesA))
- , m_getMemReq2Supported (de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_memory_requirements2"))
+ , m_getMemReq2Supported (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_get_memory_requirements2"))
, m_deviceA (createDevice(m_vkiA, m_physicalDeviceA, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
, m_vkdA (m_vkiA, *m_deviceA)
if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
TCU_THROW(NotSupportedError, "Importing image resource not supported");
+
+ if (!m_config.dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ {
+ TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory");
+ }
}
else
{
if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0
|| (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
TCU_THROW(NotSupportedError, "Exporting and importing memory type not supported");
+
+ if (!m_config.dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ {
+ TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory");
+ }
}
// Check semaphore support
vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,
- vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+ vk::VK_IMAGE_LAYOUT_UNDEFINED,
vk::VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
}
};
vk::VkRenderPass renderPass,
vk::VkFramebuffer framebuffer,
vk::VkPipeline pipeline,
+ vk::VkImage image,
+ bool isFirst,
size_t imageNextFrame,
size_t currentFrame,
deUint32 imageWidth,
VK_CHECK(vkd.beginCommandBuffer(*commandBuffer, &beginInfo));
{
+ const vk::VkImageSubresourceRange subRange =
+ {
+ vk::VK_IMAGE_ASPECT_COLOR_BIT,
+ 0,
+ 1,
+ 0,
+ 1
+ };
+ const vk::VkImageMemoryBarrier barrier =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+ DE_NULL,
+ vk::VK_ACCESS_TRANSFER_WRITE_BIT,
+ vk::VK_ACCESS_TRANSFER_READ_BIT | vk::VK_ACCESS_TRANSFER_WRITE_BIT,
+ isFirst ? vk::VK_IMAGE_LAYOUT_UNDEFINED : vk::VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+ vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+ VK_QUEUE_FAMILY_IGNORED,
+ VK_QUEUE_FAMILY_IGNORED,
+ image,
+ subRange
+ };
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1, &barrier);
+ }
+
+ {
const vk::VkClearValue clearValue = vk::makeClearValueColorF32(0.25f, 0.50f, 0.75f, 1.00f);
const vk::VkRenderPassBeginInfo renderPassBeginInfo =
{
vk::Move<vk::VkSwapchainKHR> m_swapchain;
std::vector<vk::VkImage> m_swapchainImages;
std::vector<size_t> m_imageNextFrames;
+ std::vector<bool> m_isFirst;
vk::Move<vk::VkRenderPass> m_renderPass;
vk::Move<vk::VkPipeline> m_pipeline;
m_swapchainImages = vk::wsi::getSwapchainImages(m_vkd, *m_device, *m_swapchain);
m_imageNextFrames.resize(m_swapchainImages.size(), 0);
+ m_isFirst.resize(m_swapchainImages.size(), true);
m_renderPass = createRenderPass(m_vkd, *m_device, imageFormat);
m_pipeline = createPipeline(m_vkd, *m_device, *m_renderPass, *m_pipelineLayout, *m_vertexShaderModule, *m_fragmentShaderModule, imageWidth, imageHeight);
m_swapchainImages.clear();
m_imageNextFrames.clear();
+ m_isFirst.clear();
m_swapchain = vk::Move<vk::VkSwapchainKHR>();
m_renderPass = vk::Move<vk::VkRenderPass>();
// Create command buffer
{
imageNextFrame = m_imageNextFrames[imageIndex];
- m_commandBuffers[m_frameNdx % m_commandBuffers.size()] = createCommandBuffer(m_vkd, *m_device, *m_commandPool, *m_pipelineLayout, *m_renderPass, m_framebuffers[imageIndex], *m_pipeline, imageNextFrame, m_frameNdx, width, height).disown();
+ m_commandBuffers[m_frameNdx % m_commandBuffers.size()] = createCommandBuffer(m_vkd, *m_device, *m_commandPool, *m_pipelineLayout, *m_renderPass, m_framebuffers[imageIndex], *m_pipeline, m_swapchainImages[imageIndex], m_isFirst[imageIndex], imageNextFrame, m_frameNdx, width, height).disown();
m_imageNextFrames[imageIndex] = m_frameNdx + 1;
+ m_isFirst[imageIndex] = false;
}
// Submit command buffer
projects / platform / upstream / VK-GL-CTS.git / commitdiff