anv: move CreateRayTracingPipelines to common code

Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Reviewed-by: Jason Ekstrand <jason.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17601>

src/intel/vulkan/anv_genX.h

@@ -177,3 +177,6 @@ genX(graphics_pipeline_emit)(struct anv_graphics_pipeline *pipeline,
 
 void
 genX(compute_pipeline_emit)(struct anv_compute_pipeline *pipeline);
+
+void
+genX(ray_tracing_pipeline_emit)(struct anv_ray_tracing_pipeline *pipeline);

src/intel/vulkan/anv_pipeline.c

@@ -3252,7 +3252,7 @@ anv_device_finish_rt_shaders(struct anv_device *device)
       return;
 }
 
-VkResult
+static VkResult
 anv_ray_tracing_pipeline_init(struct anv_ray_tracing_pipeline *pipeline,
                               struct anv_device *device,
                               struct vk_pipeline_cache *cache,
@@ -3279,6 +3279,152 @@ fail:
    return result;
 }
 
+static void
+assert_rt_stage_index_valid(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo,
+                            uint32_t stage_idx,
+                            VkShaderStageFlags valid_stages)
+{
+   if (stage_idx == VK_SHADER_UNUSED_KHR)
+      return;
+
+   assert(stage_idx <= pCreateInfo->stageCount);
+   assert(util_bitcount(pCreateInfo->pStages[stage_idx].stage) == 1);
+   assert(pCreateInfo->pStages[stage_idx].stage & valid_stages);
+}
+
+static VkResult
+anv_ray_tracing_pipeline_create(
+    VkDevice                                    _device,
+    struct vk_pipeline_cache *                  cache,
+    const VkRayTracingPipelineCreateInfoKHR*    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipeline)
+{
+   ANV_FROM_HANDLE(anv_device, device, _device);
+   VkResult result;
+
+   assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR);
+
+   VK_MULTIALLOC(ma);
+   VK_MULTIALLOC_DECL(&ma, struct anv_ray_tracing_pipeline, pipeline, 1);
+   VK_MULTIALLOC_DECL(&ma, struct anv_rt_shader_group, groups, pCreateInfo->groupCount);
+   if (!vk_multialloc_zalloc2(&ma, &device->vk.alloc, pAllocator,
+                              VK_SYSTEM_ALLOCATION_SCOPE_DEVICE))
+      return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+   result = anv_pipeline_init(&pipeline->base, device,
+                              ANV_PIPELINE_RAY_TRACING, pCreateInfo->flags,
+                              pAllocator);
+   if (result != VK_SUCCESS) {
+      vk_free2(&device->vk.alloc, pAllocator, pipeline);
+      return result;
+   }
+
+   pipeline->group_count = pCreateInfo->groupCount;
+   pipeline->groups = groups;
+
+   ASSERTED const VkShaderStageFlags ray_tracing_stages =
+      VK_SHADER_STAGE_RAYGEN_BIT_KHR |
+      VK_SHADER_STAGE_ANY_HIT_BIT_KHR |
+      VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR |
+      VK_SHADER_STAGE_MISS_BIT_KHR |
+      VK_SHADER_STAGE_INTERSECTION_BIT_KHR |
+      VK_SHADER_STAGE_CALLABLE_BIT_KHR;
+
+   for (uint32_t i = 0; i < pCreateInfo->stageCount; i++)
+      assert((pCreateInfo->pStages[i].stage & ~ray_tracing_stages) == 0);
+
+   for (uint32_t i = 0; i < pCreateInfo->groupCount; i++) {
+      const VkRayTracingShaderGroupCreateInfoKHR *ginfo =
+         &pCreateInfo->pGroups[i];
+      assert_rt_stage_index_valid(pCreateInfo, ginfo->generalShader,
+                                  VK_SHADER_STAGE_RAYGEN_BIT_KHR |
+                                  VK_SHADER_STAGE_MISS_BIT_KHR |
+                                  VK_SHADER_STAGE_CALLABLE_BIT_KHR);
+      assert_rt_stage_index_valid(pCreateInfo, ginfo->closestHitShader,
+                                  VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR);
+      assert_rt_stage_index_valid(pCreateInfo, ginfo->anyHitShader,
+                                  VK_SHADER_STAGE_ANY_HIT_BIT_KHR);
+      assert_rt_stage_index_valid(pCreateInfo, ginfo->intersectionShader,
+                                  VK_SHADER_STAGE_INTERSECTION_BIT_KHR);
+      switch (ginfo->type) {
+      case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
+         assert(ginfo->generalShader < pCreateInfo->stageCount);
+         assert(ginfo->anyHitShader == VK_SHADER_UNUSED_KHR);
+         assert(ginfo->closestHitShader == VK_SHADER_UNUSED_KHR);
+         assert(ginfo->intersectionShader == VK_SHADER_UNUSED_KHR);
+         break;
+
+      case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
+         assert(ginfo->generalShader == VK_SHADER_UNUSED_KHR);
+         assert(ginfo->intersectionShader == VK_SHADER_UNUSED_KHR);
+         break;
+
+      case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
+         assert(ginfo->generalShader == VK_SHADER_UNUSED_KHR);
+         break;
+
+      default:
+         unreachable("Invalid ray-tracing shader group type");
+      }
+   }
+
+   result = anv_ray_tracing_pipeline_init(pipeline, device, cache,
+                                          pCreateInfo, pAllocator);
+   if (result != VK_SUCCESS) {
+      anv_pipeline_finish(&pipeline->base, device, pAllocator);
+      vk_free2(&device->vk.alloc, pAllocator, pipeline);
+      return result;
+   }
+
+   anv_genX(&device->info, ray_tracing_pipeline_emit)(pipeline);
+
+   *pPipeline = anv_pipeline_to_handle(&pipeline->base);
+
+   return pipeline->base.batch.status;
+}
+
+VkResult
+anv_CreateRayTracingPipelinesKHR(
+    VkDevice                                    _device,
+    VkDeferredOperationKHR                      deferredOperation,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines)
+{
+   ANV_FROM_HANDLE(vk_pipeline_cache, pipeline_cache, pipelineCache);
+
+   VkResult result = VK_SUCCESS;
+
+   unsigned i;
+   for (i = 0; i < createInfoCount; i++) {
+      VkResult res = anv_ray_tracing_pipeline_create(_device, pipeline_cache,
+                                                     &pCreateInfos[i],
+                                                     pAllocator, &pPipelines[i]);
+
+      if (res == VK_SUCCESS)
+         continue;
+
+      /* Bail out on the first error as it is not obvious what error should be
+       * report upon 2 different failures. */
+      result = res;
+      if (result != VK_PIPELINE_COMPILE_REQUIRED)
+         break;
+
+      pPipelines[i] = VK_NULL_HANDLE;
+
+      if (pCreateInfos[i].flags & VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT)
+         break;
+   }
+
+   for (; i < createInfoCount; i++)
+      pPipelines[i] = VK_NULL_HANDLE;
+
+   return result;
+}
+
 #define WRITE_STR(field, ...) ({                               \
    memset(field, 0, sizeof(field));                            \
    UNUSED int i = snprintf(field, sizeof(field), __VA_ARGS__); \

src/intel/vulkan/anv_private.h

@@ -3542,13 +3542,6 @@ anv_pipeline_finish(struct anv_pipeline *pipeline,
                     struct anv_device *device,
                     const VkAllocationCallbacks *pAllocator);
 
-VkResult
-anv_ray_tracing_pipeline_init(struct anv_ray_tracing_pipeline *pipeline,
-                              struct anv_device *device,
-                              struct vk_pipeline_cache *cache,
-                              const VkRayTracingPipelineCreateInfoKHR *pCreateInfo,
-                              const VkAllocationCallbacks *alloc);
-
 struct anv_format_plane {
    enum isl_format isl_format:16;
    struct isl_swizzle swizzle;

src/intel/vulkan/genX_pipeline.c

@@ -2898,104 +2898,9 @@ genX(compute_pipeline_emit)(struct anv_compute_pipeline *pipeline)
 
 #if GFX_VERx10 >= 125
 
-static void
+void
-assert_rt_stage_index_valid(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo,
+genX(ray_tracing_pipeline_emit)(struct anv_ray_tracing_pipeline *pipeline)
-                            uint32_t stage_idx,
-                            VkShaderStageFlags valid_stages)
 {
-   if (stage_idx == VK_SHADER_UNUSED_KHR)
-      return;
-
-   assert(stage_idx <= pCreateInfo->stageCount);
-   assert(util_bitcount(pCreateInfo->pStages[stage_idx].stage) == 1);
-   assert(pCreateInfo->pStages[stage_idx].stage & valid_stages);
-}
-
-static VkResult
-ray_tracing_pipeline_create(
-    VkDevice                                    _device,
-    struct vk_pipeline_cache *                  cache,
-    const VkRayTracingPipelineCreateInfoKHR*    pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipeline*                                 pPipeline)
-{
-   ANV_FROM_HANDLE(anv_device, device, _device);
-   VkResult result;
-
-   assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR);
-
-   VK_MULTIALLOC(ma);
-   VK_MULTIALLOC_DECL(&ma, struct anv_ray_tracing_pipeline, pipeline, 1);
-   VK_MULTIALLOC_DECL(&ma, struct anv_rt_shader_group, groups, pCreateInfo->groupCount);
-   if (!vk_multialloc_zalloc2(&ma, &device->vk.alloc, pAllocator,
-                              VK_SYSTEM_ALLOCATION_SCOPE_DEVICE))
-      return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
-
-   result = anv_pipeline_init(&pipeline->base, device,
-                              ANV_PIPELINE_RAY_TRACING, pCreateInfo->flags,
-                              pAllocator);
-   if (result != VK_SUCCESS) {
-      vk_free2(&device->vk.alloc, pAllocator, pipeline);
-      return result;
-   }
-
-   pipeline->group_count = pCreateInfo->groupCount;
-   pipeline->groups = groups;
-
-   ASSERTED const VkShaderStageFlags ray_tracing_stages =
-      VK_SHADER_STAGE_RAYGEN_BIT_KHR |
-      VK_SHADER_STAGE_ANY_HIT_BIT_KHR |
-      VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR |
-      VK_SHADER_STAGE_MISS_BIT_KHR |
-      VK_SHADER_STAGE_INTERSECTION_BIT_KHR |
-      VK_SHADER_STAGE_CALLABLE_BIT_KHR;
-
-   for (uint32_t i = 0; i < pCreateInfo->stageCount; i++)
-      assert((pCreateInfo->pStages[i].stage & ~ray_tracing_stages) == 0);
-
-   for (uint32_t i = 0; i < pCreateInfo->groupCount; i++) {
-      const VkRayTracingShaderGroupCreateInfoKHR *ginfo =
-         &pCreateInfo->pGroups[i];
-      assert_rt_stage_index_valid(pCreateInfo, ginfo->generalShader,
-                                  VK_SHADER_STAGE_RAYGEN_BIT_KHR |
-                                  VK_SHADER_STAGE_MISS_BIT_KHR |
-                                  VK_SHADER_STAGE_CALLABLE_BIT_KHR);
-      assert_rt_stage_index_valid(pCreateInfo, ginfo->closestHitShader,
-                                  VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR);
-      assert_rt_stage_index_valid(pCreateInfo, ginfo->anyHitShader,
-                                  VK_SHADER_STAGE_ANY_HIT_BIT_KHR);
-      assert_rt_stage_index_valid(pCreateInfo, ginfo->intersectionShader,
-                                  VK_SHADER_STAGE_INTERSECTION_BIT_KHR);
-      switch (ginfo->type) {
-      case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR:
-         assert(ginfo->generalShader < pCreateInfo->stageCount);
-         assert(ginfo->anyHitShader == VK_SHADER_UNUSED_KHR);
-         assert(ginfo->closestHitShader == VK_SHADER_UNUSED_KHR);
-         assert(ginfo->intersectionShader == VK_SHADER_UNUSED_KHR);
-         break;
-
-      case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR:
-         assert(ginfo->generalShader == VK_SHADER_UNUSED_KHR);
-         assert(ginfo->intersectionShader == VK_SHADER_UNUSED_KHR);
-         break;
-
-      case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR:
-         assert(ginfo->generalShader == VK_SHADER_UNUSED_KHR);
-         break;
-
-      default:
-         unreachable("Invalid ray-tracing shader group type");
-      }
-   }
-
-   result = anv_ray_tracing_pipeline_init(pipeline, device, cache,
-                                          pCreateInfo, pAllocator);
-   if (result != VK_SUCCESS) {
-      anv_pipeline_finish(&pipeline->base, device, pAllocator);
-      vk_free2(&device->vk.alloc, pAllocator, pipeline);
-      return result;
-   }
-
    for (uint32_t i = 0; i < pipeline->group_count; i++) {
       struct anv_rt_shader_group *group = &pipeline->groups[i];
 
@@ -3030,48 +2935,14 @@ ray_tracing_pipeline_create(
          unreachable("Invalid shader group type");
       }
    }
-
-   *pPipeline = anv_pipeline_to_handle(&pipeline->base);
-
-   return pipeline->base.batch.status;
 }
 
-VkResult
+#else
-genX(CreateRayTracingPipelinesKHR)(
+
-    VkDevice                                    _device,
+void
-    VkDeferredOperationKHR                      deferredOperation,
+genX(ray_tracing_pipeline_emit)(struct anv_ray_tracing_pipeline *pipeline)
-    VkPipelineCache                             pipelineCache,
-    uint32_t                                    createInfoCount,
-    const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipeline*                                 pPipelines)
 {
-   VK_FROM_HANDLE(vk_pipeline_cache, pipeline_cache, pipelineCache);
+   unreachable("Ray tracing not supported");
-
-   VkResult result = VK_SUCCESS;
-
-   unsigned i;
-   for (i = 0; i < createInfoCount; i++) {
-      VkResult res = ray_tracing_pipeline_create(_device, pipeline_cache,
-                                                 &pCreateInfos[i],
-                                                 pAllocator, &pPipelines[i]);
-
-      if (res == VK_SUCCESS)
-         continue;
-
-      /* Bail out on the first error as it is not obvious what error should be
-       * report upon 2 different failures. */
-      result = res;
-      if (result != VK_PIPELINE_COMPILE_REQUIRED)
-         break;
-
-      if (pCreateInfos[i].flags & VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT)
-         break;
-   }
-
-   for (; i < createInfoCount; i++)
-      pPipelines[i] = VK_NULL_HANDLE;
-
-   return result;
 }
+
 #endif /* GFX_VERx10 >= 125 */