Test that repeated redundant calls for spin-sync aren't serialised

* If the application is calling e.g. vkGetFenceStatus() in a loop we don't want
  to serialise every call.

util/test/demos/vk/vk_helpers.h

@@ -341,19 +341,37 @@ struct SemaphoreCreateInfo : public VkSemaphoreCreateInfo
     flags = 0;
   }
 
+  SemaphoreCreateInfo &next(const void *next)
+  {
+    this->pNext = next;
+    return *this;
+  }
+
   operator const VkSemaphoreCreateInfo *() const { return this; }
 };
 
 struct FenceCreateInfo : public VkFenceCreateInfo
 {
-  FenceCreateInfo() : VkFenceCreateInfo()
+  FenceCreateInfo(VkFenceCreateFlags flags = 0) : VkFenceCreateInfo()
   {
     sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
     pNext = NULL;
+    this->flags = flags;
+  }
+
+  operator const VkFenceCreateInfo *() const { return this; }
+};
+
+struct EventCreateInfo : public VkEventCreateInfo
+{
+  EventCreateInfo() : VkEventCreateInfo()
+  {
+    sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+    pNext = NULL;
     flags = 0;
   }
 
-  operator const VkFenceCreateInfo *() const { return this; }
+  operator const VkEventCreateInfo *() const { return this; }
 };
 
 struct CommandPoolCreateInfo : public VkCommandPoolCreateInfo

util/test/demos/vk/vk_parameter_zoo.cpp

@@ -171,13 +171,30 @@ void main()
     };
   }
 
-  int main()
+  void Prepare(int argc, char **argv)
   {
     optDevExts.push_back(VK_EXT_TOOLING_INFO_EXTENSION_NAME);
     optDevExts.push_back(VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
     optDevExts.push_back(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
     optDevExts.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
+    optDevExts.push_back(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME);
 
+    VulkanGraphicsTest::Prepare(argc, argv);
+
+    static VkPhysicalDeviceTimelineSemaphoreFeaturesKHR timeline = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR,
+    };
+
+    if(std::find(devExts.begin(), devExts.end(), VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME) !=
+       devExts.end())
+    {
+      timeline.timelineSemaphore = VK_TRUE;
+      devInfoNext = &timeline;
+    }
+  }
+
+  int main()
+  {
     // initialise, create window, create context, etc
     if(!Init())
       return 3;
@@ -204,6 +221,9 @@ void main()
     bool EXT_transform_feedback =
         std::find(devExts.begin(), devExts.end(), VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME) !=
         devExts.end();
+    bool KHR_timeline_semaphore =
+        std::find(devExts.begin(), devExts.end(), VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME) !=
+        devExts.end();
 
     VkDescriptorSetLayout setlayout = createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo({
         {0, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
@@ -866,6 +886,23 @@ void main()
     AllocatedBuffer xfbBuf(this, vkh::BufferCreateInfo(256, xfbUsage),
                            VmaAllocationCreateInfo({0, VMA_MEMORY_USAGE_GPU_ONLY}));
 
+    VkFence fence;
+    CHECK_VKR(vkCreateFence(device, vkh::FenceCreateInfo(VK_FENCE_CREATE_SIGNALED_BIT), NULL, &fence));
+
+    VkEvent ev;
+    CHECK_VKR(vkCreateEvent(device, vkh::EventCreateInfo(), NULL, &ev));
+
+    VkSemaphore sem = VK_NULL_HANDLE;
+
+    if(KHR_timeline_semaphore)
+    {
+      VkSemaphoreTypeCreateInfo semType = {VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO};
+      semType.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
+      semType.initialValue = 1234;
+
+      CHECK_VKR(vkCreateSemaphore(device, vkh::SemaphoreCreateInfo().next(&semType), NULL, &sem));
+    }
+
     while(Running())
     {
       // acquire and clear the backbuffer
@@ -886,6 +923,28 @@ void main()
         Submit(0, 4, {cmd});
       }
 
+      // do a bunch of spinning on fences/semaphores that should not be serialised exhaustively
+      VkResult status = VK_SUCCESS;
+      for(size_t i = 0; i < 1000; i++)
+        status = vkGetFenceStatus(device, fence);
+
+      if(status != VK_SUCCESS)
+        TEST_WARN("Expected fence to be set (it was created signalled)");
+
+      for(size_t i = 0; i < 1000; i++)
+        status = vkGetEventStatus(device, ev);
+
+      if(status != VK_EVENT_RESET)
+        TEST_WARN("Expected event to be unset");
+
+      uint64_t val = 0;
+      if(KHR_timeline_semaphore)
+        for(size_t i = 0; i < 1000; i++)
+          vkGetSemaphoreCounterValueKHR(device, sem, &val);
+
+      if(val != 1234)
+        TEST_WARN("Expected timeline semaphore value to be 1234");
+
       // reference some resources through different descriptor types to ensure that they are
       // properly included
       {
@@ -1121,6 +1180,10 @@ void main()
 
     vkDeviceWaitIdle(device);
 
+    vkDestroyEvent(device, ev, NULL);
+    vkDestroyFence(device, fence, NULL);
+    vkDestroySemaphore(device, sem, NULL);
+
     vkDestroySampler(device, validSampler, NULL);
 
     vkDestroyImageView(device, view1, NULL);

util/test/demos/vk/vk_test.cpp

@@ -339,6 +339,23 @@ void VulkanGraphicsTest::Prepare(int argc, char **argv)
   std::vector<VkExtensionProperties> supportedExts;
   CHECK_VKR(vkh::enumerateDeviceExtensionProperties(supportedExts, phys, NULL));
 
+  // add any optional extensions that are supported
+  for(const char *search : optDevExts)
+  {
+    bool found = false;
+    for(VkExtensionProperties &ext : supportedExts)
+    {
+      if(!strcmp(ext.extensionName, search))
+      {
+        found = true;
+        break;
+      }
+    }
+
+    if(found)
+      devExts.push_back(search);
+  }
+
   vkGetPhysicalDeviceProperties(phys, &physProperties);
 
   instVersion = vulkanVersion;

util/test/tests/Vulkan/VK_Parameter_Zoo.py

@@ -122,3 +122,9 @@ class VK_Parameter_Zoo(rdtest.TestCase):
         self.check(any([d.name == 'RenderDoc' for d in draw.children]))
 
         rdtest.log.success("RenderDoc tool was listed as available")
+
+        # Check for resource leaks
+        if len(self.controller.GetStructuredFile().chunks) > 500:
+            raise rdtest.TestFailureException(
+                "Too many chunks found: {}".format(len(self.controller.GetStructuredFile().chunks)))
+