void uploadBuffer (tcu::ConstPixelBufferAccess bufferAccess, const Allocation& bufferAlloc);
void uploadImage (const tcu::ConstPixelBufferAccess& src, VkImage dst, const ImageParms& parms, const deUint32 mipLevels = 1u);
virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region) = 0;
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u) = 0;
deUint32 calculateSize (tcu::ConstPixelBufferAccess src) const
{
return src.getWidth() * src.getHeight() * src.getDepth() * tcu::getPixelSize(src.getFormat());
Move<VkImage> m_destination;
de::MovePtr<Allocation> m_destinationImageAlloc;
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u);
};
CopyImageToImage::CopyImageToImage (Context& context, TestParams params)
return tcu::TestStatus::pass("CopiesAndBlitting test");
}
-void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void CopyImageToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
VkOffset3D srcOffset = region.imageCopy.srcOffset;
VkOffset3D dstOffset = region.imageCopy.dstOffset;
VkExtent3D extent = region.imageCopy.extent;
const TestParams params)
: vkt::TestCase (testCtx, name, description)
, m_params (params)
- {}
+ {}
virtual TestInstance* createInstance (Context& context) const
- {
- return new CopyImageToImage(context, m_params);
- }
+ {
+ return new CopyImageToImage(context, m_params);
+ }
+
+ virtual void checkSupport (Context& context) const
+ {
+ if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
+ {
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
+ }
+
+ if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
+ (m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
+ {
+ if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
+ TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
+ }
+
+ VkImageFormatProperties properties;
+ if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
+ m_params.src.image.format,
+ m_params.src.image.imageType,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+ 0,
+ &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
+ (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
+ m_params.dst.image.format,
+ m_params.dst.image.imageType,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+ 0,
+ &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
+ {
+ TCU_THROW(NotSupportedError, "Format not supported");
+ }
+ }
+
private:
TestParams m_params;
};
CopyBufferToBuffer (Context& context, TestParams params);
virtual tcu::TestStatus iterate (void);
private:
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess, tcu::PixelBufferAccess, CopyRegion, deUint32 mipLevel = 0u);
Move<VkBuffer> m_source;
de::MovePtr<Allocation> m_sourceBufferAlloc;
Move<VkBuffer> m_destination;
return checkTestResult(resultLevel->getAccess());
}
-void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void CopyBufferToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
deMemcpy((deUint8*) dst.getDataPtr() + region.bufferCopy.dstOffset,
(deUint8*) src.getDataPtr() + region.bufferCopy.srcOffset,
(size_t)region.bufferCopy.size);
TestParams testParams);
virtual tcu::TestStatus iterate (void);
private:
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u);
tcu::TextureFormat m_textureFormat;
VkDeviceSize m_bufferSize;
TestParams m_params;
};
-void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void CopyImageToBuffer::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
if (!rowLength)
rowLength = region.bufferImageCopy.imageExtent.width;
TestParams testParams);
virtual tcu::TestStatus iterate (void);
private:
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u);
tcu::TextureFormat m_textureFormat;
VkDeviceSize m_bufferSize;
TestParams m_params;
};
-void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void CopyBufferToImage::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
deUint32 rowLength = region.bufferImageCopy.bufferRowLength;
if (!rowLength)
rowLength = region.bufferImageCopy.imageExtent.width;
virtual tcu::TestStatus iterate (void);
protected:
virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result);
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u);
virtual void generateExpectedResult (void);
private:
bool checkLinearFilteredResult (const tcu::ConstPixelBufferAccess& result,
return MIRROR_MODE_LAST;
}
-void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void BlittingImages::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
region.imageBlit.srcOffsets[1],
region.imageBlit.dstOffsets[0],
virtual tcu::TestStatus iterate (void);
protected:
virtual tcu::TestStatus checkTestResult (tcu::ConstPixelBufferAccess result = tcu::ConstPixelBufferAccess());
- virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region);
+ virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel = 0u);
virtual void generateExpectedResult (void);
private:
bool checkLinearFilteredResult (void);
for (deUint32 mipLevelNdx = 0u; mipLevelNdx < m_params.mipLevels; mipLevelNdx++)
{
+ // Update reference results with previous results that have been verified.
+ // This needs to be done such that accumulated errors don't exceed the fixed threshold.
+ for (deUint32 i = 0; i < m_params.regions.size(); i++)
+ {
+ const CopyRegion region = m_params.regions[i];
+ const deUint32 srcMipLevel = m_params.regions[i].imageBlit.srcSubresource.mipLevel;
+ const deUint32 dstMipLevel = m_params.regions[i].imageBlit.dstSubresource.mipLevel;
+ de::MovePtr<tcu::TextureLevel> prevResultLevel;
+ tcu::ConstPixelBufferAccess src;
+ if (srcMipLevel < mipLevelNdx)
+ {
+ // Generate expected result from rendered result that was previously verified
+ prevResultLevel = readImage(*m_destination, m_params.dst.image, srcMipLevel);
+ src = prevResultLevel->getAccess();
+ }
+ else
+ {
+ // Previous reference mipmaps might have changed, so recompute expected result
+ src = m_expectedTextureLevel[srcMipLevel]->getAccess();
+ }
+ copyRegionToTextureLevel(src, m_expectedTextureLevel[dstMipLevel]->getAccess(), region, dstMipLevel);
+ }
+
de::MovePtr<tcu::TextureLevel> resultLevel = readImage(*m_destination, m_params.dst.image, mipLevelNdx);
const tcu::ConstPixelBufferAccess& resultAccess = resultLevel->getAccess();
return tcu::TestStatus::pass("Pass");
}
-void BlittingMipmaps::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void BlittingMipmaps::copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_ASSERT(src.getDepth() == dst.getDepth());
+
const MirrorMode mirrorMode = getMirrorMode(region.imageBlit.srcOffsets[0],
region.imageBlit.srcOffsets[1],
region.imageBlit.dstOffsets[0],
}
else
{
- const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, srcExtent.x, srcExtent.y);
- const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
- blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
-
- if (filter == tcu::Sampler::LINEAR)
+ for (int layerNdx = 0u; layerNdx < src.getDepth(); layerNdx++)
{
- const tcu::PixelBufferAccess unclampedSubRegion = tcu::getSubregion(m_unclampedExpectedTextureLevel[0]->getAccess(), dstOffset.x, dstOffset.y, dstExtent.x, dstExtent.y);
- scaleFromWholeSrcBuffer(unclampedSubRegion, src, srcOffset, srcExtent, filter);
+ const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y, layerNdx, srcExtent.x, srcExtent.y, 1);
+ const tcu::PixelBufferAccess dstSubRegion = tcu::getSubregion(dst, dstOffset.x, dstOffset.y, layerNdx, dstExtent.x, dstExtent.y, 1);
+ blit(dstSubRegion, srcSubRegion, filter, mirrorMode);
+
+ if (filter == tcu::Sampler::LINEAR)
+ {
+ const tcu::PixelBufferAccess unclampedSubRegion = tcu::getSubregion(m_unclampedExpectedTextureLevel[mipLevel]->getAccess(), dstOffset.x, dstOffset.y, layerNdx, dstExtent.x, dstExtent.y, 1);
+ scaleFromWholeSrcBuffer(unclampedSubRegion, srcSubRegion, srcOffset, srcExtent, filter);
+ }
}
}
}
virtual void copyRegionToTextureLevel (tcu::ConstPixelBufferAccess src,
tcu::PixelBufferAccess dst,
- CopyRegion region);
+ CopyRegion region,
+ deUint32 dstMipLevel);
};
ResolveImageToImage::ResolveImageToImage (Context& context, TestParams params, const ResolveImageToImageOptions options)
return tcu::TestStatus::pass("CopiesAndBlitting test");
}
-void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region)
+void ResolveImageToImage::copyRegionToTextureLevel(tcu::ConstPixelBufferAccess src, tcu::PixelBufferAccess dst, CopyRegion region, deUint32 mipLevel)
{
+ DE_UNREF(mipLevel);
+
VkOffset3D srcOffset = region.imageResolve.srcOffset;
srcOffset.z = region.imageResolve.srcSubresource.baseArrayLayer;
VkOffset3D dstOffset = region.imageResolve.dstOffset;
vk::VK_IMAGE_CREATE_SPARSE_BINDING_BIT|vk::VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
vk::VK_IMAGE_CREATE_SPARSE_BINDING_BIT|vk::VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
vk::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
- vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
- vk::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
+ vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
};
const vk::VkImageUsageFlags usageFlags[] =
{
{
m_heaps[heapNdx].heap = m_memoryProperties.memoryHeaps[heapNdx];
m_heaps[heapNdx].memoryUsage = 0;
- m_heaps[heapNdx].maxMemoryUsage = m_heaps[heapNdx].heap.size / 2; /* Use at maximum 50% of heap */
+ m_heaps[heapNdx].maxMemoryUsage = m_heaps[heapNdx].heap.size / 8; /* Use at maximum 12.5% of heap */
m_heaps[heapNdx].objects.reserve(100);
}
vk.cmdEndRenderPass(*cmdBuffer);
{
+ // Image validator reads image in compute shader
const vk::VkImageMemoryBarrier endImgBarrier =
{
vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
}
};
vk.cmdPipelineBarrier(*cmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
vk.cmdEndRenderPass(*cmdBuffer);
{
+ // Image validator reads image in compute shader
const vk::VkImageMemoryBarrier endImgBarrier =
{
vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
}
};
vk.cmdPipelineBarrier(*cmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
vk.cmdPipelineBarrier(targetCmdBuffer,
vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
};
vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
1, &initializeBarrier);
}
- // Start destination buffer barrier
- {
- const vk::VkBufferMemoryBarrier startBufferBarrier =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0, // VkAccessFlags srcAccessMask
- vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
- queueFamilyIndex, // uint32_t srcQueueFamilyIndex
- queueFamilyIndex, // uint32_t dstQueueFamilyIndex
- **dstBuffer, // VkBuffer buffer
- 0u, // VkDeviceSize offset
- VK_WHOLE_SIZE, // VkDeviceSize size
- };
-
- vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- (vk::VkDependencyFlags)0,
- 0, (const vk::VkMemoryBarrier*)DE_NULL,
- 1, &startBufferBarrier,
- 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
- }
-
-
// Copy image to buffer
const vk::VkImageSubresourceLayers subresourceLayers =
{
vk.cmdCopyImageToBuffer(targetCmdBuffer, **colorImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, **dstBuffer, 1u, ©Region);
{
+ // Buffer validator reads buffer in compute shader
const vk::VkBufferMemoryBarrier endBufferBarrier =
{
vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
VK_WHOLE_SIZE, // VkDeviceSize size
};
vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
+ vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
1, &endBufferBarrier,
switch (m_cmdType) {
case FILL_BUFFER:
{
- const vk::VkBufferMemoryBarrier startFillBufferBarrier =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0, // VkAccessFlags srcAccessMask
- vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
- queueFamilyIndex, // uint32_t srcQueueFamilyIndex
- queueFamilyIndex, // uint32_t dstQueueFamilyIndex
- **dstBuffer, // VkBuffer buffer
- 0u, // VkDeviceSize offset
- VK_WHOLE_SIZE, // VkDeviceSize size
- };
- vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- (vk::VkDependencyFlags) 0,
- 0, (const vk::VkMemoryBarrier *) DE_NULL,
- 1, &startFillBufferBarrier,
- 0, (const vk::VkImageMemoryBarrier *) DE_NULL);
// Fill buffer
vk.cmdFillBuffer(targetCmdBuffer, **dstBuffer, 0u, VK_WHOLE_SIZE, m_fillValue);
break;
case UPDATE_BUFFER:
{
- const vk::VkBufferMemoryBarrier startUpdateBufferBarrier =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0, // VkAccessFlags srcAccessMask
- vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
- queueFamilyIndex, // uint32_t srcQueueFamilyIndex
- queueFamilyIndex, // uint32_t dstQueueFamilyIndex
- **dstBuffer, // VkBuffer buffer
- 0u, // VkDeviceSize offset
- VK_WHOLE_SIZE, // VkDeviceSize size
- };
- vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- (vk::VkDependencyFlags) 0,
- 0, (const vk::VkMemoryBarrier *) DE_NULL,
- 1, &startUpdateBufferBarrier,
- 0, (const vk::VkImageMemoryBarrier *) DE_NULL);
// Update buffer
deUint32 data[BUFFER_SIZE];
for (size_t ndx = 0; ndx < BUFFER_SIZE; ndx++)
case COPY_BUFFER:
{
- // Start src buffer barrier
- const vk::VkBufferMemoryBarrier startBufferBarrier =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0, // VkAccessFlags srcAccessMask
- vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
- queueFamilyIndex, // uint32_t srcQueueFamilyIndex
- queueFamilyIndex, // uint32_t dstQueueFamilyIndex
- **srcBuffer, // VkBuffer buffer
- 0u, // VkDeviceSize offset
- VK_WHOLE_SIZE, // VkDeviceSize size
- };
- vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- (vk::VkDependencyFlags) 0,
- 0, (const vk::VkMemoryBarrier *) DE_NULL,
- 1, &startBufferBarrier,
- 0, (const vk::VkImageMemoryBarrier *) DE_NULL);
vk.cmdFillBuffer(targetCmdBuffer, **srcBuffer, 0u, VK_WHOLE_SIZE, m_fillValue);
- // Barrier to change accessMask to transfer read bit for source buffer
- const vk::VkBufferMemoryBarrier startCopyBufferBarrier =
+ const vk::VkBufferMemoryBarrier copyBufferBarrier =
{
vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
DE_NULL, // const void* pNext
VK_WHOLE_SIZE, // VkDeviceSize size
};
- // Image barrier for destination buffer
- const vk::VkBufferMemoryBarrier dstBufferBarrier =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0, // VkAccessFlags srcAccessMask
- vk::VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask
- queueFamilyIndex, // uint32_t srcQueueFamilyIndex
- queueFamilyIndex, // uint32_t dstQueueFamilyIndex
- **dstBuffer, // VkBuffer buffer
- 0u, // VkDeviceSize offset
- VK_WHOLE_SIZE, // VkDeviceSize size
- };
-
- const vk::VkBufferMemoryBarrier memoryBarriers[2] =
- {
- startCopyBufferBarrier,
- dstBufferBarrier
- };
vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
+ vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
- 2, memoryBarriers,
+ 1, ©BufferBarrier,
0, (const vk::VkImageMemoryBarrier*)DE_NULL);
+
// Copy buffer
const vk::VkBufferCopy copyBufferRegion =
{
}
{
+ // Buffer validator reads buffer in compute shader
const vk::VkBufferMemoryBarrier endBufferBarrier =
{
vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
VK_WHOLE_SIZE, // VkDeviceSize size
};
vk.cmdPipelineBarrier(targetCmdBuffer,
- vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
+ vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
(vk::VkDependencyFlags)0,
0, (const vk::VkMemoryBarrier*)DE_NULL,
1, &endBufferBarrier,
// Determine the maximum memory heap space available for protected images
vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(context.getInstanceDriver(), context.getPhysicalDevice());
vk::VkDeviceSize protectedHeapSize = 0;
+ vk::VkDeviceSize maxMemoryUsage = 0;
deUint32 protectedHeapMask = 0;
+
for (deUint32 memType = 0; memType < memoryProperties.memoryTypeCount; memType++)
{
deUint32 heapIndex = memoryProperties.memoryTypes[memType].heapIndex;
(protectedHeapMask & (1u << heapIndex)) == 0)
{
protectedHeapSize = de::max(protectedHeapSize, memoryProperties.memoryHeaps[heapIndex].size);
+ maxMemoryUsage = protectedHeapSize / 4 ; /* Use at maximum 25% of heap */
protectedHeapMask |= 1u << heapIndex;
}
}
// If the implementation doesn't have a max image count, min+16 means we won't clamp.
- // Limit it to how many protected images we estimate can be allocated, with two images
- // worth of slack for alignment, swapchain-specific constraints, etc.
+ // Limit it to how many protected images we estimate can be allocated - 25% of heap size
const deUint32 maxImageCount = de::min((capabilities.maxImageCount > 0) ? capabilities.maxImageCount : capabilities.minImageCount + 16u,
- deUint32(protectedHeapSize / memoryRequirements.size) - 2);
+ deUint32(maxMemoryUsage / memoryRequirements.size));
+ if (maxImageCount < capabilities.minImageCount)
+ TCU_THROW(NotSupportedError, "Memory heap doesn't have enough memory!.");
+
const deUint32 maxImageCountToTest = de::clamp(16u, capabilities.minImageCount, maxImageCount);
for (deUint32 imageCount = capabilities.minImageCount; imageCount <= maxImageCountToTest; ++imageCount)
{
{ 117, 998 },
};
+ const vk::DeviceInterface& vkd = context.getDeviceInterface();
+ vk::VkDevice device = context.getDevice();
+ vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(context.getInstanceDriver(), context.getPhysicalDevice());
+ vk::VkDeviceSize protectedHeapSize = 0;
+ vk::VkDeviceSize maxMemoryUsage = 0;
+
+ for (deUint32 memType = 0; memType < memoryProperties.memoryTypeCount; memType++)
+ {
+ deUint32 heapIndex = memoryProperties.memoryTypes[memType].heapIndex;
+ if (memoryProperties.memoryTypes[memType].propertyFlags & vk::VK_MEMORY_PROPERTY_PROTECTED_BIT)
+ {
+ protectedHeapSize = de::max(protectedHeapSize, memoryProperties.memoryHeaps[heapIndex].size);
+ maxMemoryUsage = protectedHeapSize / 4 ; /* Use at maximum 25% of heap */
+ }
+ }
+
if (platformProperties.swapchainExtent == vk::wsi::PlatformProperties::SWAPCHAIN_EXTENT_SETS_WINDOW_SIZE ||
platformProperties.swapchainExtent == vk::wsi::PlatformProperties::SWAPCHAIN_EXTENT_SCALED_TO_WINDOW_SIZE)
{
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_testSizes); ++ndx)
{
- cases.push_back(baseParameters);
- cases.back().imageExtent.width = de::clamp(s_testSizes[ndx].width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
- cases.back().imageExtent.height = de::clamp(s_testSizes[ndx].height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
+ vk::VkMemoryRequirements memoryRequirements;
+ {
+ const vk::VkImageCreateInfo imageInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ DE_NULL,
+ vk::VK_IMAGE_CREATE_PROTECTED_BIT,
+ vk::VK_IMAGE_TYPE_2D,
+ baseParameters.imageFormat,
+ {
+ s_testSizes[ndx].width,
+ s_testSizes[ndx].height,
+ 1,
+ },
+ 1, // mipLevels
+ baseParameters.imageArrayLayers,
+ vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ baseParameters.imageUsage,
+ baseParameters.imageSharingMode,
+ baseParameters.queueFamilyIndexCount,
+ baseParameters.pQueueFamilyIndices,
+ vk::VK_IMAGE_LAYOUT_UNDEFINED
+ };
+
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &imageInfo);
+
+ memoryRequirements = vk::getImageMemoryRequirements(vkd, device, *image);
+ }
+
+ // Check for the image size requirement based on double/triple buffering
+ if (memoryRequirements.size * capabilities.minImageCount < maxMemoryUsage)
+ {
+ cases.push_back(baseParameters);
+ cases.back().imageExtent.width = de::clamp(s_testSizes[ndx].width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
+ cases.back().imageExtent.height = de::clamp(s_testSizes[ndx].height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
+ }
}
}
if (platformProperties.swapchainExtent != vk::wsi::PlatformProperties::SWAPCHAIN_EXTENT_SETS_WINDOW_SIZE)
{
- cases.push_back(baseParameters);
- cases.back().imageExtent = capabilities.currentExtent;
+ vk::VkMemoryRequirements memoryRequirements;
+ {
+ const vk::VkImageCreateInfo imageInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ DE_NULL,
+ vk::VK_IMAGE_CREATE_PROTECTED_BIT,
+ vk::VK_IMAGE_TYPE_2D,
+ baseParameters.imageFormat,
+ {
+ capabilities.currentExtent.width,
+ capabilities.currentExtent.height,
+ 1,
+ },
+ 1, // mipLevels
+ baseParameters.imageArrayLayers,
+ vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ baseParameters.imageUsage,
+ baseParameters.imageSharingMode,
+ baseParameters.queueFamilyIndexCount,
+ baseParameters.pQueueFamilyIndices,
+ vk::VK_IMAGE_LAYOUT_UNDEFINED
+ };
+
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &imageInfo);
+
+ memoryRequirements = vk::getImageMemoryRequirements(vkd, device, *image);
+ }
+
+ // Check for the image size requirement based on double/triple buffering
+ if (memoryRequirements.size * capabilities.minImageCount < maxMemoryUsage)
+ {
+ cases.push_back(baseParameters);
+ cases.back().imageExtent = capabilities.currentExtent;
+ }
}
if (platformProperties.swapchainExtent != vk::wsi::PlatformProperties::SWAPCHAIN_EXTENT_MUST_MATCH_WINDOW_SIZE)
{
- cases.push_back(baseParameters);
- cases.back().imageExtent = capabilities.minImageExtent;
+ static const vk::VkExtent2D s_testExtentSizes[] =
+ {
+ { capabilities.minImageExtent.width, capabilities.minImageExtent.height },
+ { capabilities.maxImageExtent.width, capabilities.maxImageExtent.height },
+ };
- cases.push_back(baseParameters);
- cases.back().imageExtent = capabilities.maxImageExtent;
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_testExtentSizes); ++ndx)
+ {
+ vk::VkMemoryRequirements memoryRequirements;
+ {
+ const vk::VkImageCreateInfo imageInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+ DE_NULL,
+ vk::VK_IMAGE_CREATE_PROTECTED_BIT,
+ vk::VK_IMAGE_TYPE_2D,
+ baseParameters.imageFormat,
+ {
+ s_testExtentSizes[ndx].width,
+ s_testExtentSizes[ndx].height,
+ 1,
+ },
+ 1, // mipLevels
+ baseParameters.imageArrayLayers,
+ vk::VK_SAMPLE_COUNT_1_BIT,
+ vk::VK_IMAGE_TILING_OPTIMAL,
+ baseParameters.imageUsage,
+ baseParameters.imageSharingMode,
+ baseParameters.queueFamilyIndexCount,
+ baseParameters.pQueueFamilyIndices,
+ vk::VK_IMAGE_LAYOUT_UNDEFINED
+ };
+
+ vk::Move<vk::VkImage> image = vk::createImage(vkd, device, &imageInfo);
+
+ memoryRequirements = vk::getImageMemoryRequirements(vkd, device, *image);
+ }
+
+ // Check for the image size requirement based on double/triple buffering
+ if (memoryRequirements.size * capabilities.minImageCount < maxMemoryUsage)
+ {
+ cases.push_back(baseParameters);
+ cases.back().imageExtent =s_testExtentSizes[ndx];
+ }
+ }
}
break;
deUint32 encodedValue;
if (isAlpha)
- encodedValue = deMin32(deUint32(normValue * 0x3u), 0x3u);
+ encodedValue = deMin32(deUint32(deFloatRound(normValue * 0x3u)), 0x3u);
else
- encodedValue = deMin32(deUint32(normValue * 0x3FFu), 0x3FFu);
+ encodedValue = deMin32(deUint32(deFloatRound(normValue * 0x3FFu)), 0x3FFu);
if (encodedValue == 0)
return true;
projects / platform / upstream / VK-GL-CTS.git / commitdiff