Fixes sync test shader instance counts

Tests incorrectly required implementations to
execute only 1 vs instance per vertex.

Components: Vulkan
VK-GL-CTS Issue: 1958

Affects:
dEQP-VK.synchronization.op.*.write_indirect_buffer*

Change-Id: I17e42658706712a4f9d07931ac234c1e1807d693

diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
index 25fc89e..13b54f3 100644 (file)
--- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
@@ -1188,48 +1188,64 @@ tcu::TestStatus SharingTestInstance::iterate (void)
 
                        DE_ASSERT(expected.size == actual.size);
 
-                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                       if (!isIndirectBuffer(m_config.resource.type))
                        {
-                               const size_t            maxBytesLogged  = 256;
-                               std::ostringstream      expectedData;
-                               std::ostringstream      actualData;
-                               size_t                          byteNdx                 = 0;
-
-                               // Find first byte difference
-                               for (; actual.data[byteNdx] == expected.data[byteNdx]; byteNdx++)
+                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
                                {
-                                       // Nothing
-                               }
+                                       const size_t            maxBytesLogged = 256;
+                                       std::ostringstream      expectedData;
+                                       std::ostringstream      actualData;
+                                       size_t                          byteNdx = 0;
 
-                               log << TestLog::Message << "First different byte at offset: " << byteNdx << TestLog::EndMessage;
+                                       // Find first byte difference
+                                       for (; actual.data[byteNdx] == expected.data[byteNdx]; byteNdx++)
+                                       {
+                                               // Nothing
+                                       }
 
-                               // Log 8 previous bytes before the first incorrect byte
-                               if (byteNdx > 8)
-                               {
-                                       expectedData << "... ";
-                                       actualData << "... ";
+                                       log << TestLog::Message << "First different byte at offset: " << byteNdx << TestLog::EndMessage;
 
-                                       byteNdx -= 8;
-                               }
-                               else
-                                       byteNdx = 0;
+                                       // Log 8 previous bytes before the first incorrect byte
+                                       if (byteNdx > 8)
+                                       {
+                                               expectedData << "... ";
+                                               actualData << "... ";
 
-                               for (size_t i = 0; i < maxBytesLogged && byteNdx < expected.size; i++, byteNdx++)
-                               {
-                                       expectedData << (i > 0 ? ", " : "") << (deUint32)expected.data[byteNdx];
-                                       actualData << (i > 0 ? ", " : "") << (deUint32)actual.data[byteNdx];
-                               }
+                                               byteNdx -= 8;
+                                       }
+                                       else
+                                               byteNdx = 0;
 
-                               if (expected.size > byteNdx)
-                               {
-                                       expectedData << "...";
-                                       actualData << "...";
+                                       for (size_t i = 0; i < maxBytesLogged && byteNdx < expected.size; i++, byteNdx++)
+                                       {
+                                               expectedData << (i > 0 ? ", " : "") << (deUint32)expected.data[byteNdx];
+                                               actualData << (i > 0 ? ", " : "") << (deUint32)actual.data[byteNdx];
+                                       }
+
+                                       if (expected.size > byteNdx)
+                                       {
+                                               expectedData << "...";
+                                               actualData << "...";
+                                       }
+
+                                       log << TestLog::Message << "Expected data: (" << expectedData.str() << ")" << TestLog::EndMessage;
+                                       log << TestLog::Message << "Actual data: (" << actualData.str() << ")" << TestLog::EndMessage;
+
+                                       m_resultCollector.fail("Memory contents don't match");
                                }
+                       }
+                       else
+                       {
+                               const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                               const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
 
-                               log << TestLog::Message << "Expected data: (" << expectedData.str() << ")" << TestLog::EndMessage;
-                               log << TestLog::Message << "Actual data: (" << actualData.str() << ")" << TestLog::EndMessage;
+                               if (actualValue < expectedValue)
+                               {
+                                       log << TestLog::Message << "Expected counter value: (" << expectedValue << ")" << TestLog::EndMessage;
+                                       log << TestLog::Message << "Actual counter value: (" << actualValue << ")" << TestLog::EndMessage;
 
-                               m_resultCollector.fail("Memory contents don't match");
+                                       m_resultCollector.fail("Counter value is smaller than expected");
+                               }
                        }
                }
        }

diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationMultiQueueTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationMultiQueueTests.cpp
index 8f97897..8a292e7 100644 (file)
--- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationMultiQueueTests.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationMultiQueueTests.cpp
@@ -374,8 +374,19 @@ public:
                                const Data      expected        = writeOp->getData();
                                const Data      actual          = readOp->getData();
 
-                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                                       return tcu::TestStatus::fail("Memory contents don't match");
+                               if (isIndirectBuffer(m_resourceDesc.type))
+                               {
+                                       const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                                       const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                                       if (actualValue < expectedValue)
+                                               return tcu::TestStatus::fail("Counter value is smaller than expected");
+                               }
+                               else
+                               {
+                                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                               return tcu::TestStatus::fail("Memory contents don't match");
+                               }
                        }
                }
                return tcu::TestStatus::pass("OK");
@@ -441,8 +452,19 @@ public:
                                const Data      expected = writeOp->getData();
                                const Data      actual   = readOp->getData();
 
-                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                                       return tcu::TestStatus::fail("Memory contents don't match");
+                               if (isIndirectBuffer(m_resourceDesc.type))
+                               {
+                                       const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                                       const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                                       if (actualValue < expectedValue)
+                                               return tcu::TestStatus::fail("Counter value is smaller than expected");
+                               }
+                               else
+                               {
+                                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                               return tcu::TestStatus::fail("Memory contents don't match");
+                               }
                        }
                }
                return tcu::TestStatus::pass("OK");

diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp
index 6115d45..79ab520 100644 (file)
--- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationOperationSingleQueueTests.cpp
@@ -115,8 +115,19 @@ public:
                        const Data      expected = m_writeOp->getData();
                        const Data      actual   = m_readOp->getData();
 
-                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                               return tcu::TestStatus::fail("Memory contents don't match");
+                       if (isIndirectBuffer(m_resource->getType()))
+                       {
+                               const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                               const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                               if (actualValue < expectedValue)
+                                       return tcu::TestStatus::fail("Counter value is smaller than expected");
+                       }
+                       else
+                       {
+                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                       return tcu::TestStatus::fail("Memory contents don't match");
+                       }
                }
 
                return tcu::TestStatus::pass("OK");
@@ -169,8 +180,19 @@ public:
                        const Data      expected = m_writeOp->getData();
                        const Data      actual   = m_readOp->getData();
 
-                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                               return tcu::TestStatus::fail("Memory contents don't match");
+                       if (isIndirectBuffer(m_resource->getType()))
+                       {
+                               const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                               const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                               if (actualValue < expectedValue)
+                                       return tcu::TestStatus::fail("Counter value is smaller than expected");
+                       }
+                       else
+                       {
+                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                       return tcu::TestStatus::fail("Memory contents don't match");
+                       }
                }
 
                return tcu::TestStatus::pass("OK");
@@ -257,8 +279,19 @@ public:
                        const Data      expected = m_writeOp->getData();
                        const Data      actual   = m_readOp->getData();
 
-                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                               return tcu::TestStatus::fail("Memory contents don't match");
+                       if (isIndirectBuffer(m_resource->getType()))
+                       {
+                               const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                               const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                               if (actualValue < expectedValue)
+                                       return tcu::TestStatus::fail("Counter value is smaller than expected");
+                       }
+                       else
+                       {
+                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                       return tcu::TestStatus::fail("Memory contents don't match");
+                       }
                }
 
                return tcu::TestStatus::pass("OK");
@@ -313,8 +346,19 @@ public:
                        const Data      expected = m_writeOp->getData();
                        const Data      actual   = m_readOp->getData();
 
-                       if (0 != deMemCmp(expected.data, actual.data, expected.size))
-                               return tcu::TestStatus::fail("Memory contents don't match");
+                       if (isIndirectBuffer(m_resource->getType()))
+                       {
+                               const deUint32 expectedValue = reinterpret_cast<const deUint32*>(expected.data)[0];
+                               const deUint32 actualValue   = reinterpret_cast<const deUint32*>(actual.data)[0];
+
+                               if (actualValue < expectedValue)
+                                       return tcu::TestStatus::fail("Counter value is smaller than expected");
+                       }
+                       else
+                       {
+                               if (0 != deMemCmp(expected.data, actual.data, expected.size))
+                                       return tcu::TestStatus::fail("Memory contents don't match");
+                       }
                }
 
                return tcu::TestStatus::pass("OK");