mirrors
/
mesa
mirror of https://gitlab.freedesktop.org/mesa/mesa
1
0
Fork 0
Code Issues 9 Packages Projects Releases Wiki Activity
mesa/src/virtio/vulkan/vn_pipeline.c

790 lines
27 KiB
C
Raw Blame History

/*
* Copyright 2019 Google LLC
* SPDX-License-Identifier: MIT
*
* based in part on anv and radv which are:
* Copyright © 2015 Intel Corporation
* Copyright © 2016 Red Hat.
* Copyright © 2016 Bas Nieuwenhuizen
*/
#include "vn_pipeline.h"
#include "venus-protocol/vn_protocol_driver_pipeline.h"
#include "venus-protocol/vn_protocol_driver_pipeline_cache.h"
#include "venus-protocol/vn_protocol_driver_pipeline_layout.h"
#include "venus-protocol/vn_protocol_driver_shader_module.h"
#include "vn_device.h"
#include "vn_physical_device.h"
#include "vn_render_pass.h"
/* shader module commands */
VkResult
vn_CreateShaderModule(VkDevice device,
const VkShaderModuleCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkShaderModule *pShaderModule)
{
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
struct vn_shader_module *mod =
vk_zalloc(alloc, sizeof(*mod), VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!mod)
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vn_object_base_init(&mod->base, VK_OBJECT_TYPE_SHADER_MODULE, &dev->base);
VkShaderModule mod_handle = vn_shader_module_to_handle(mod);
vn_async_vkCreateShaderModule(dev->instance, device, pCreateInfo, NULL,
&mod_handle);
*pShaderModule = mod_handle;
return VK_SUCCESS;
}
void
vn_DestroyShaderModule(VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks *pAllocator)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_shader_module *mod = vn_shader_module_from_handle(shaderModule);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
if (!mod)
return;
vn_async_vkDestroyShaderModule(dev->instance, device, shaderModule, NULL);
vn_object_base_fini(&mod->base);
vk_free(alloc, mod);
}
/* pipeline layout commands */
VkResult
vn_CreatePipelineLayout(VkDevice device,
const VkPipelineLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkPipelineLayout *pPipelineLayout)
{
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
struct vn_pipeline_layout *layout =
vk_zalloc(alloc, sizeof(*layout), VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!layout)
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vn_object_base_init(&layout->base, VK_OBJECT_TYPE_PIPELINE_LAYOUT,
&dev->base);
VkPipelineLayout layout_handle = vn_pipeline_layout_to_handle(layout);
vn_async_vkCreatePipelineLayout(dev->instance, device, pCreateInfo, NULL,
&layout_handle);
*pPipelineLayout = layout_handle;
return VK_SUCCESS;
}
void
vn_DestroyPipelineLayout(VkDevice device,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks *pAllocator)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_pipeline_layout *layout =
vn_pipeline_layout_from_handle(pipelineLayout);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
if (!layout)
return;
vn_async_vkDestroyPipelineLayout(dev->instance, device, pipelineLayout,
NULL);
vn_object_base_fini(&layout->base);
vk_free(alloc, layout);
}
/* pipeline cache commands */
VkResult
vn_CreatePipelineCache(VkDevice device,
const VkPipelineCacheCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkPipelineCache *pPipelineCache)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
struct vn_pipeline_cache *cache =
vk_zalloc(alloc, sizeof(*cache), VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!cache)
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vn_object_base_init(&cache->base, VK_OBJECT_TYPE_PIPELINE_CACHE,
&dev->base);
VkPipelineCacheCreateInfo local_create_info;
if (pCreateInfo->initialDataSize) {
const struct vk_pipeline_cache_header *header =
pCreateInfo->pInitialData;
local_create_info = *pCreateInfo;
local_create_info.initialDataSize -= header->header_size;
local_create_info.pInitialData += header->header_size;
pCreateInfo = &local_create_info;
}
VkPipelineCache cache_handle = vn_pipeline_cache_to_handle(cache);
vn_async_vkCreatePipelineCache(dev->instance, device, pCreateInfo, NULL,
&cache_handle);
*pPipelineCache = cache_handle;
return VK_SUCCESS;
}
void
vn_DestroyPipelineCache(VkDevice device,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks *pAllocator)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_pipeline_cache *cache =
vn_pipeline_cache_from_handle(pipelineCache);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
if (!cache)
return;
vn_async_vkDestroyPipelineCache(dev->instance, device, pipelineCache,
NULL);
vn_object_base_fini(&cache->base);
vk_free(alloc, cache);
}
VkResult
vn_GetPipelineCacheData(VkDevice device,
VkPipelineCache pipelineCache,
size_t *pDataSize,
void *pData)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_physical_device *physical_dev = dev->physical_device;
struct vk_pipeline_cache_header *header = pData;
VkResult result;
if (!pData) {
result = vn_call_vkGetPipelineCacheData(dev->instance, device,
pipelineCache, pDataSize, NULL);
if (result != VK_SUCCESS)
return vn_error(dev->instance, result);
*pDataSize += sizeof(*header);
return VK_SUCCESS;
}
if (*pDataSize <= sizeof(*header)) {
*pDataSize = 0;
return VK_INCOMPLETE;
}
const VkPhysicalDeviceProperties *props =
&physical_dev->properties.vulkan_1_0;
header->header_size = sizeof(*header);
header->header_version = VK_PIPELINE_CACHE_HEADER_VERSION_ONE;
header->vendor_id = props->vendorID;
header->device_id = props->deviceID;
memcpy(header->uuid, props->pipelineCacheUUID, VK_UUID_SIZE);
*pDataSize -= header->header_size;
result =
vn_call_vkGetPipelineCacheData(dev->instance, device, pipelineCache,
pDataSize, pData + header->header_size);
if (result < VK_SUCCESS)
return vn_error(dev->instance, result);
*pDataSize += header->header_size;
return result;
}
VkResult
vn_MergePipelineCaches(VkDevice device,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache *pSrcCaches)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
vn_async_vkMergePipelineCaches(dev->instance, device, dstCache,
srcCacheCount, pSrcCaches);
return VK_SUCCESS;
}
/* pipeline commands */
static bool
vn_create_pipeline_handles(struct vn_device *dev,
uint32_t pipeline_count,
VkPipeline *pipeline_handles,
const VkAllocationCallbacks *alloc)
{
for (uint32_t i = 0; i < pipeline_count; i++) {
struct vn_pipeline *pipeline =
vk_zalloc(alloc, sizeof(*pipeline), VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pipeline) {
for (uint32_t j = 0; j < i; j++) {
pipeline = vn_pipeline_from_handle(pipeline_handles[j]);
vn_object_base_fini(&pipeline->base);
vk_free(alloc, pipeline);
}
memset(pipeline_handles, 0,
pipeline_count * sizeof(pipeline_handles[0]));
return false;
}
vn_object_base_init(&pipeline->base, VK_OBJECT_TYPE_PIPELINE,
&dev->base);
pipeline_handles[i] = vn_pipeline_to_handle(pipeline);
}
return true;
}
/** For vkCreate*Pipelines. */
static void
vn_destroy_failed_pipelines(struct vn_device *dev,
uint32_t create_info_count,
VkPipeline *pipelines,
const VkAllocationCallbacks *alloc)
{
for (uint32_t i = 0; i < create_info_count; i++) {
struct vn_pipeline *pipeline = vn_pipeline_from_handle(pipelines[i]);
if (pipeline->base.id == 0) {
vn_object_base_fini(&pipeline->base);
vk_free(alloc, pipeline);
pipelines[i] = VK_NULL_HANDLE;
}
}
}
#define VN_PIPELINE_CREATE_SYNC_MASK \
(VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT | \
VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT)
/** Fixes for a single VkGraphicsPipelineCreateInfo. */
struct vn_graphics_pipeline_create_info_fix {
bool ignore_tessellation_state;
bool ignore_viewport_state;
bool ignore_viewports;
bool ignore_scissors;
bool ignore_multisample_state;
bool ignore_depth_stencil_state;
bool ignore_color_blend_state;
bool ignore_base_pipeline_handle;
};
/** Temporary storage for fixes in vkCreateGraphicsPipelines. */
struct vn_create_graphics_pipelines_fixes {
VkGraphicsPipelineCreateInfo *create_infos;
VkPipelineViewportStateCreateInfo *viewport_state_create_infos;
};
static struct vn_create_graphics_pipelines_fixes *
vn_alloc_create_graphics_pipelines_fixes(const VkAllocationCallbacks *alloc,
uint32_t info_count)
{
struct vn_create_graphics_pipelines_fixes *fixes;
VkGraphicsPipelineCreateInfo *create_infos;
VkPipelineViewportStateCreateInfo *viewport_state_create_infos;
VK_MULTIALLOC(ma);
vk_multialloc_add(&ma, &fixes, __typeof__(*fixes), 1);
vk_multialloc_add(&ma, &create_infos, __typeof__(*create_infos),
info_count);
vk_multialloc_add(&ma, &viewport_state_create_infos,
__typeof__(*viewport_state_create_infos), info_count);
if (!vk_multialloc_zalloc(&ma, alloc, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND))
return NULL;
fixes->create_infos = create_infos;
fixes->viewport_state_create_infos = viewport_state_create_infos;
return fixes;
}
static const VkGraphicsPipelineCreateInfo *
vn_fix_graphics_pipeline_create_info(
struct vn_device *dev,
uint32_t info_count,
const VkGraphicsPipelineCreateInfo *create_infos,
const VkAllocationCallbacks *alloc,
struct vn_create_graphics_pipelines_fixes **out_fixes)
{
VN_TRACE_FUNC();
/* Defer allocation until we need a fix. */
struct vn_create_graphics_pipelines_fixes *fixes = NULL;
for (uint32_t i = 0; i < info_count; i++) {
struct vn_graphics_pipeline_create_info_fix fix = { 0 };
bool any_fix = false;
const VkGraphicsPipelineCreateInfo *info = &create_infos[i];
const VkPipelineRenderingCreateInfo *rendering_info =
vk_find_struct_const(info, PIPELINE_RENDERING_CREATE_INFO);
VkShaderStageFlags stages = 0;
for (uint32_t j = 0; j < info->stageCount; j++) {
stages |= info->pStages[j].stage;
}
/* VkDynamicState */
struct {
bool rasterizer_discard_enable;
bool viewport;
bool viewport_with_count;
bool scissor;
bool scissor_with_count;
} has_dynamic_state = { 0 };
if (info->pDynamicState) {
for (uint32_t j = 0; j < info->pDynamicState->dynamicStateCount;
j++) {
switch (info->pDynamicState->pDynamicStates[j]) {
case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE:
has_dynamic_state.rasterizer_discard_enable = true;
break;
case VK_DYNAMIC_STATE_VIEWPORT:
has_dynamic_state.viewport = true;
break;
case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT:
has_dynamic_state.viewport_with_count = true;
break;
case VK_DYNAMIC_STATE_SCISSOR:
has_dynamic_state.scissor = true;
break;
case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT:
has_dynamic_state.scissor_with_count = true;
break;
default:
break;
}
}
}
const struct vn_render_pass *pass =
vn_render_pass_from_handle(info->renderPass);
const struct vn_subpass *subpass = NULL;
if (pass)
subpass = &pass->subpasses[info->subpass];
/* TODO: Ignore VkPipelineRenderingCreateInfo when not using dynamic
* rendering. This requires either a deep rewrite of
* VkGraphicsPipelineCreateInfo::pNext or a fix in the generated
* protocol code.
*
* The Vulkan spec (1.3.223) says about VkPipelineRenderingCreateInfo:
* If a graphics pipeline is created with a valid VkRenderPass,
* parameters of this structure are ignored.
*/
const bool has_dynamic_rendering = !pass && rendering_info;
/* For each pipeline state category, we define a bool.
*
* The Vulkan spec (1.3.223) says:
* The state required for a graphics pipeline is divided into vertex
* input state, pre-rasterization shader state, fragment shader
* state, and fragment output state.
*
* Without VK_EXT_graphics_pipeline_library, most states are
* unconditionally included in the pipeline. Despite that, we still
* reference the state bools in the ignore rules because (a) it makes
* the ignore condition easier to validate against the text of the
* relevant VUs; and (b) it makes it easier to enable
* VK_EXT_graphics_pipeline_library because we won't need to carefully
* revisit the text of each VU to untangle the missing pipeline state
* bools.
*/
/* VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT
*
* The Vulkan spec (1.3.223) says:
* If the pre-rasterization shader state includes a vertex shader,
* then vertex input state is included in a complete graphics pipeline.
*
* We support no extension yet that allows the vertex stage to be
* omitted, such as VK_EXT_vertex_input_dynamic_state or
* VK_EXT_graphics_pipeline_library.
*/
const bool UNUSED has_vertex_input_state = true;
/* VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT */
const bool has_pre_raster_state = true;
/* The spec does not assign a name to this state. We define it just to
* deduplicate code.
*
* The Vulkan spec (1.3.223) says:
* If the value of [...]rasterizerDiscardEnable in the
* pre-rasterization shader state is VK_FALSE or the
* VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state is
* enabled fragment shader state and fragment output interface state
* is included in a complete graphics pipeline.
*/
const bool has_raster_state =
has_dynamic_state.rasterizer_discard_enable ||
(info->pRasterizationState &&
info->pRasterizationState->rasterizerDiscardEnable == VK_FALSE);
/* VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT */
const bool has_fragment_shader_state = has_raster_state;
/* VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT */
const bool has_fragment_output_state = has_raster_state;
/* Ignore pTessellationState?
* VUID-VkGraphicsPipelineCreateInfo-pStages-00731
*/
if (info->pTessellationState &&
(!(stages & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
!(stages & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))) {
fix.ignore_tessellation_state = true;
any_fix = true;
}
/* Ignore pViewportState?
* VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750
* VUID-VkGraphicsPipelineCreateInfo-pViewportState-04892
*/
if (info->pViewportState &&
!(has_pre_raster_state && has_raster_state)) {
fix.ignore_viewport_state = true;
any_fix = true;
}
/* Ignore pViewports?
* VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04130
*
* Even if pViewportState is non-null, we must not dereference it if it
* is ignored.
*/
if (!fix.ignore_viewport_state && info->pViewportState &&
info->pViewportState->pViewports) {
const bool has_dynamic_viewport =
has_pre_raster_state && (has_dynamic_state.viewport ||
has_dynamic_state.viewport_with_count);
if (has_dynamic_viewport) {
fix.ignore_viewports = true;
any_fix = true;
}
}
/* Ignore pScissors?
* VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-04131
*
* Even if pViewportState is non-null, we must not dereference it if it
* is ignored.
*/
if (!fix.ignore_viewport_state && info->pViewportState &&
info->pViewportState->pScissors) {
const bool has_dynamic_scissor =
has_pre_raster_state && (has_dynamic_state.scissor ||
has_dynamic_state.scissor_with_count);
if (has_dynamic_scissor) {
fix.ignore_scissors = true;
any_fix = true;
}
}
/* Ignore pMultisampleState?
* VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751
*/
if (info->pMultisampleState && !has_fragment_output_state) {
fix.ignore_multisample_state = true;
any_fix = true;
}
/* Ignore pDepthStencilState? */
if (info->pDepthStencilState) {
const bool has_static_attachment =
subpass && subpass->has_depth_stencil_attachment;
/* VUID-VkGraphicsPipelineCreateInfo-renderPass-06043 */
bool require_state =
has_fragment_shader_state && has_static_attachment;
if (!require_state) {
const bool has_dynamic_attachment =
has_dynamic_rendering &&
(rendering_info->depthAttachmentFormat !=
VK_FORMAT_UNDEFINED ||
rendering_info->stencilAttachmentFormat !=
VK_FORMAT_UNDEFINED);
/* VUID-VkGraphicsPipelineCreateInfo-renderPass-06053 */
require_state = has_fragment_shader_state &&
has_fragment_output_state &&
has_dynamic_attachment;
}
fix.ignore_depth_stencil_state = !require_state;
any_fix |= fix.ignore_depth_stencil_state;
}
/* Ignore pColorBlendState? */
if (info->pColorBlendState) {
const bool has_static_attachment =
subpass && subpass->has_color_attachment;
/* VUID-VkGraphicsPipelineCreateInfo-renderPass-06044 */
bool require_state =
has_fragment_output_state && has_static_attachment;
if (!require_state) {
const bool has_dynamic_attachment =
has_dynamic_rendering && rendering_info->colorAttachmentCount;
/* VUID-VkGraphicsPipelineCreateInfo-renderPass-06054 */
require_state =
has_fragment_output_state && has_dynamic_attachment;
}
fix.ignore_color_blend_state = !require_state;
any_fix |= fix.ignore_color_blend_state;
}
/* Ignore basePipelineHandle?
* VUID-VkGraphicsPipelineCreateInfo-flags-00722
*/
if (!(info->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) ||
info->basePipelineIndex != -1) {
fix.ignore_base_pipeline_handle = true;
any_fix = true;
}
if (!any_fix)
continue;
if (!fixes) {
fixes = vn_alloc_create_graphics_pipelines_fixes(alloc, info_count);
if (!fixes)
return NULL;
memcpy(fixes->create_infos, create_infos,
info_count * sizeof(create_infos[0]));
}
if (fix.ignore_tessellation_state)
fixes->create_infos[i].pTessellationState = NULL;
if (fix.ignore_viewport_state)
fixes->create_infos[i].pViewportState = NULL;
if (fixes->create_infos[i].pViewportState) {
if (fix.ignore_viewports || fix.ignore_scissors) {
fixes->viewport_state_create_infos[i] = *info->pViewportState;
fixes->create_infos[i].pViewportState =
&fixes->viewport_state_create_infos[i];
}
if (fix.ignore_viewports)
fixes->viewport_state_create_infos[i].pViewports = NULL;
if (fix.ignore_scissors)
fixes->viewport_state_create_infos[i].pScissors = NULL;
}
if (fix.ignore_multisample_state)
fixes->create_infos[i].pMultisampleState = NULL;
if (fix.ignore_depth_stencil_state)
fixes->create_infos[i].pDepthStencilState = NULL;
if (fix.ignore_color_blend_state)
fixes->create_infos[i].pColorBlendState = NULL;
if (fix.ignore_base_pipeline_handle)
fixes->create_infos[i].basePipelineHandle = VK_NULL_HANDLE;
}
if (!fixes)
return create_infos;
*out_fixes = fixes;
return fixes->create_infos;
}
/**
* We invalidate each VkPipelineCreationFeedback. This is a legal but useless
* implementation.
*
* We invalidate because the venus protocol (as of 2022-08-25) does not know
* that the VkPipelineCreationFeedback structs in the
* VkGraphicsPipelineCreateInfo pNext are output parameters. Before
* VK_EXT_pipeline_creation_feedback, the pNext chain was input-only.
*/
static void
vn_invalidate_pipeline_creation_feedback(const VkBaseInStructure *chain)
{
const VkPipelineCreationFeedbackCreateInfo *feedback_info =
vk_find_struct_const(chain, PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
if (!feedback_info)
return;
feedback_info->pPipelineCreationFeedback->flags &=
~VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
for (uint32_t i = 0; i < feedback_info->pipelineStageCreationFeedbackCount;
i++) {
feedback_info->pPipelineStageCreationFeedbacks[i].flags &=
~VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
}
}
VkResult
vn_CreateGraphicsPipelines(VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator,
VkPipeline *pPipelines)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
struct vn_create_graphics_pipelines_fixes *fixes = NULL;
bool want_sync = false;
VkResult result;
pCreateInfos = vn_fix_graphics_pipeline_create_info(
dev, createInfoCount, pCreateInfos, alloc, &fixes);
if (!pCreateInfos)
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!vn_create_pipeline_handles(dev, createInfoCount, pPipelines, alloc)) {
vk_free(alloc, fixes);
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
}
for (uint32_t i = 0; i < createInfoCount; i++) {
if ((pCreateInfos[i].flags & VN_PIPELINE_CREATE_SYNC_MASK))
want_sync = true;
vn_invalidate_pipeline_creation_feedback(
(const VkBaseInStructure *)pCreateInfos[i].pNext);
}
if (want_sync) {
result = vn_call_vkCreateGraphicsPipelines(
dev->instance, device, pipelineCache, createInfoCount, pCreateInfos,
NULL, pPipelines);
if (result != VK_SUCCESS)
vn_destroy_failed_pipelines(dev, createInfoCount, pPipelines, alloc);
} else {
vn_async_vkCreateGraphicsPipelines(dev->instance, device, pipelineCache,
createInfoCount, pCreateInfos, NULL,
pPipelines);
result = VK_SUCCESS;
}
vk_free(alloc, fixes);
return vn_result(dev->instance, result);
}
VkResult
vn_CreateComputePipelines(VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator,
VkPipeline *pPipelines)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
bool want_sync = false;
VkResult result;
if (!vn_create_pipeline_handles(dev, createInfoCount, pPipelines, alloc))
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
for (uint32_t i = 0; i < createInfoCount; i++) {
if ((pCreateInfos[i].flags & VN_PIPELINE_CREATE_SYNC_MASK))
want_sync = true;
vn_invalidate_pipeline_creation_feedback(
(const VkBaseInStructure *)pCreateInfos[i].pNext);
}
if (want_sync) {
result = vn_call_vkCreateComputePipelines(
dev->instance, device, pipelineCache, createInfoCount, pCreateInfos,
NULL, pPipelines);
if (result != VK_SUCCESS)
vn_destroy_failed_pipelines(dev, createInfoCount, pPipelines, alloc);
} else {
vn_call_vkCreateComputePipelines(dev->instance, device, pipelineCache,
createInfoCount, pCreateInfos, NULL,
pPipelines);
result = VK_SUCCESS;
}
return vn_result(dev->instance, result);
}
void
vn_DestroyPipeline(VkDevice device,
VkPipeline _pipeline,
const VkAllocationCallbacks *pAllocator)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_pipeline *pipeline = vn_pipeline_from_handle(_pipeline);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
if (!pipeline)
return;
vn_async_vkDestroyPipeline(dev->instance, device, _pipeline, NULL);
vn_object_base_fini(&pipeline->base);
vk_free(alloc, pipeline);
}
Reference in New Issue View Git Blame Copy Permalink