anv/device: Fix version check

[mesa.git] / src / vulkan / anv_query.c

diff --git a/src/vulkan/anv_query.c b/src/vulkan/anv_query.c
index 6f9d7d89aa6c6f8a964ebda50dd5bb0b51811974..5b052341e0cbe0de486649f2b98ea61677872673 100644 (file)
--- a/src/vulkan/anv_query.c
+++ b/src/vulkan/anv_query.c
@@ -45,26 +45,24 @@ VkResult anv_CreateQueryPool(
 
    switch (pCreateInfo->queryType) {
    case VK_QUERY_TYPE_OCCLUSION:
-      slot_size = sizeof(struct anv_query_pool_slot);
+   case VK_QUERY_TYPE_TIMESTAMP:
       break;
    case VK_QUERY_TYPE_PIPELINE_STATISTICS:
       return VK_ERROR_INCOMPATIBLE_DRIVER;
-   case VK_QUERY_TYPE_TIMESTAMP:
-      slot_size = sizeof(uint64_t);
-      break;
    default:
       assert(!"Invalid query type");
    }
 
+   slot_size = sizeof(struct anv_query_pool_slot);
    pool = anv_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8,
                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    if (pool == NULL)
       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 
    pool->type = pCreateInfo->queryType;
-   pool->slots = pCreateInfo->entryCount;
+   pool->slots = pCreateInfo->queryCount;
 
-   size = pCreateInfo->entryCount * slot_size;
+   size = pCreateInfo->queryCount * slot_size;
    result = anv_bo_init_new(&pool->bo, device, size);
    if (result != VK_SUCCESS)
       goto fail;
@@ -97,7 +95,7 @@ void anv_DestroyQueryPool(
 VkResult anv_GetQueryPoolResults(
     VkDevice                                    _device,
     VkQueryPool                                 queryPool,
-    uint32_t                                    startQuery,
+    uint32_t                                    firstQuery,
     uint32_t                                    queryCount,
     size_t                                      dataSize,
     void*                                       pData,
@@ -110,12 +108,6 @@ VkResult anv_GetQueryPoolResults(
    uint64_t result;
    int ret;
 
-   if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
-      /* Where is the availabilty info supposed to go? */
-      anv_finishme("VK_QUERY_RESULT_WITH_AVAILABILITY_BIT");
-      return VK_ERROR_INCOMPATIBLE_DRIVER;
-   }
-
    assert(pool->type == VK_QUERY_TYPE_OCCLUSION ||
           pool->type == VK_QUERY_TYPE_TIMESTAMP);
 
@@ -132,20 +124,19 @@ VkResult anv_GetQueryPoolResults(
    }
 
    void *data_end = pData + dataSize;
+   struct anv_query_pool_slot *slot = pool->bo.map;
 
    for (uint32_t i = 0; i < queryCount; i++) {
       switch (pool->type) {
       case VK_QUERY_TYPE_OCCLUSION: {
-         struct anv_query_pool_slot *slot = pool->bo.map;
-         result = slot[startQuery + i].end - slot[startQuery + i].begin;
+         result = slot[firstQuery + i].end - slot[firstQuery + i].begin;
          break;
       }
       case VK_QUERY_TYPE_PIPELINE_STATISTICS:
          /* Not yet implemented */
          break;
       case VK_QUERY_TYPE_TIMESTAMP: {
-         uint64_t *slot = pool->bo.map;
-         result = slot[startQuery + i];
+         result = slot[firstQuery + i].begin;
          break;
       }
       default:
@@ -153,12 +144,19 @@ VkResult anv_GetQueryPoolResults(
       }
 
       if (flags & VK_QUERY_RESULT_64_BIT) {
-         *(uint64_t *)pData = result;
+         uint64_t *dst = pData;
+         dst[0] = result;
+         if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
+            dst[1] = slot[firstQuery + i].available;
       } else {
+         uint32_t *dst = pData;
          if (result > UINT32_MAX)
             result = UINT32_MAX;
-         *(uint32_t *)pData = result;
+         dst[0] = result;
+         if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
+            dst[1] = slot[firstQuery + i].available;
       }
+
       pData += stride;
       if (pData >= data_end)
          break;
@@ -170,8 +168,21 @@ VkResult anv_GetQueryPoolResults(
 void anv_CmdResetQueryPool(
     VkCommandBuffer                             commandBuffer,
     VkQueryPool                                 queryPool,
-    uint32_t                                    startQuery,
+    uint32_t                                    firstQuery,
     uint32_t                                    queryCount)
 {
-   stub();
+   ANV_FROM_HANDLE(anv_query_pool, pool, queryPool);
+
+   for (uint32_t i = 0; i < queryCount; i++) {
+      switch (pool->type) {
+      case VK_QUERY_TYPE_OCCLUSION:
+      case VK_QUERY_TYPE_TIMESTAMP: {
+         struct anv_query_pool_slot *slot = pool->bo.map;
+         slot[firstQuery + i].available = 0;
+         break;
+      }
+      default:
+         assert(!"Invalid query type");
+      }
+   }
 }