From abf9e10488c9fc8b7af8f284d4de31ebf3092299 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Wed, 22 May 2019 18:25:50 -0500 Subject: [PATCH] anv: Use dirty bits for dynamic state tracking Previously, we assumed that the dirty bit was always 1 << VK_DYNAMIC_* and this assumption is about to be false. Extensions which define new VK_DYNAMIC_* enums won't be nice and tightly packed which this really requires. Instead, add functions to don the conversions and rework the bits a bit. Reviewed-by: Lionel Landwerlin --- src/intel/vulkan/anv_cmd_buffer.c | 20 +++++++------- src/intel/vulkan/anv_pipeline.c | 24 +++++++++-------- src/intel/vulkan/anv_private.h | 43 +++++++++++++++++++++++++++++-- 3 files changed, 64 insertions(+), 23 deletions(-) diff --git a/src/intel/vulkan/anv_cmd_buffer.c b/src/intel/vulkan/anv_cmd_buffer.c index 0e54603ea30..d3887ae1ec6 100644 --- a/src/intel/vulkan/anv_cmd_buffer.c +++ b/src/intel/vulkan/anv_cmd_buffer.c @@ -77,39 +77,39 @@ const struct anv_dynamic_state default_dynamic_state = { void anv_dynamic_state_copy(struct anv_dynamic_state *dest, const struct anv_dynamic_state *src, - uint32_t copy_mask) + anv_cmd_dirty_mask_t copy_mask) { - if (copy_mask & (1 << VK_DYNAMIC_STATE_VIEWPORT)) { + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) { dest->viewport.count = src->viewport.count; typed_memcpy(dest->viewport.viewports, src->viewport.viewports, src->viewport.count); } - if (copy_mask & (1 << VK_DYNAMIC_STATE_SCISSOR)) { + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) { dest->scissor.count = src->scissor.count; typed_memcpy(dest->scissor.scissors, src->scissor.scissors, src->scissor.count); } - if (copy_mask & (1 << VK_DYNAMIC_STATE_LINE_WIDTH)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH) dest->line_width = src->line_width; - if (copy_mask & (1 << VK_DYNAMIC_STATE_DEPTH_BIAS)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS) dest->depth_bias = src->depth_bias; - if (copy_mask & (1 << VK_DYNAMIC_STATE_BLEND_CONSTANTS)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS) typed_memcpy(dest->blend_constants, src->blend_constants, 4); - if (copy_mask & (1 << VK_DYNAMIC_STATE_DEPTH_BOUNDS)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS) dest->depth_bounds = src->depth_bounds; - if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK) dest->stencil_compare_mask = src->stencil_compare_mask; - if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_WRITE_MASK)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK) dest->stencil_write_mask = src->stencil_write_mask; - if (copy_mask & (1 << VK_DYNAMIC_STATE_STENCIL_REFERENCE)) + if (copy_mask & ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE) dest->stencil_reference = src->stencil_reference; } diff --git a/src/intel/vulkan/anv_pipeline.c b/src/intel/vulkan/anv_pipeline.c index a9a403f1233..002ff00d538 100644 --- a/src/intel/vulkan/anv_pipeline.c +++ b/src/intel/vulkan/anv_pipeline.c @@ -1505,8 +1505,10 @@ copy_non_dynamic_state(struct anv_pipeline *pipeline, if (pCreateInfo->pDynamicState) { /* Remove all of the states that are marked as dynamic */ uint32_t count = pCreateInfo->pDynamicState->dynamicStateCount; - for (uint32_t s = 0; s < count; s++) - states &= ~(1 << pCreateInfo->pDynamicState->pDynamicStates[s]); + for (uint32_t s = 0; s < count; s++) { + states &= ~anv_cmd_dirty_bit_for_vk_dynamic_state( + pCreateInfo->pDynamicState->pDynamicStates[s]); + } } struct anv_dynamic_state *dynamic = &pipeline->dynamic_state; @@ -1520,26 +1522,26 @@ copy_non_dynamic_state(struct anv_pipeline *pipeline, assert(pCreateInfo->pViewportState); dynamic->viewport.count = pCreateInfo->pViewportState->viewportCount; - if (states & (1 << VK_DYNAMIC_STATE_VIEWPORT)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) { typed_memcpy(dynamic->viewport.viewports, pCreateInfo->pViewportState->pViewports, pCreateInfo->pViewportState->viewportCount); } dynamic->scissor.count = pCreateInfo->pViewportState->scissorCount; - if (states & (1 << VK_DYNAMIC_STATE_SCISSOR)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) { typed_memcpy(dynamic->scissor.scissors, pCreateInfo->pViewportState->pScissors, pCreateInfo->pViewportState->scissorCount); } } - if (states & (1 << VK_DYNAMIC_STATE_LINE_WIDTH)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH) { assert(pCreateInfo->pRasterizationState); dynamic->line_width = pCreateInfo->pRasterizationState->lineWidth; } - if (states & (1 << VK_DYNAMIC_STATE_DEPTH_BIAS)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS) { assert(pCreateInfo->pRasterizationState); dynamic->depth_bias.bias = pCreateInfo->pRasterizationState->depthBiasConstantFactor; @@ -1567,7 +1569,7 @@ copy_non_dynamic_state(struct anv_pipeline *pipeline, !pCreateInfo->pRasterizationState->rasterizerDiscardEnable) { assert(pCreateInfo->pColorBlendState); - if (states & (1 << VK_DYNAMIC_STATE_BLEND_CONSTANTS)) + if (states & ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS) typed_memcpy(dynamic->blend_constants, pCreateInfo->pColorBlendState->blendConstants, 4); } @@ -1588,28 +1590,28 @@ copy_non_dynamic_state(struct anv_pipeline *pipeline, subpass->depth_stencil_attachment) { assert(pCreateInfo->pDepthStencilState); - if (states & (1 << VK_DYNAMIC_STATE_DEPTH_BOUNDS)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS) { dynamic->depth_bounds.min = pCreateInfo->pDepthStencilState->minDepthBounds; dynamic->depth_bounds.max = pCreateInfo->pDepthStencilState->maxDepthBounds; } - if (states & (1 << VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK) { dynamic->stencil_compare_mask.front = pCreateInfo->pDepthStencilState->front.compareMask; dynamic->stencil_compare_mask.back = pCreateInfo->pDepthStencilState->back.compareMask; } - if (states & (1 << VK_DYNAMIC_STATE_STENCIL_WRITE_MASK)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK) { dynamic->stencil_write_mask.front = pCreateInfo->pDepthStencilState->front.writeMask; dynamic->stencil_write_mask.back = pCreateInfo->pDepthStencilState->back.writeMask; } - if (states & (1 << VK_DYNAMIC_STATE_STENCIL_REFERENCE)) { + if (states & ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE) { dynamic->stencil_reference.front = pCreateInfo->pDepthStencilState->front.reference; dynamic->stencil_reference.back = diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h index aa799d2aefc..f46a87e8e7c 100644 --- a/src/intel/vulkan/anv_private.h +++ b/src/intel/vulkan/anv_private.h @@ -1947,7 +1947,6 @@ enum anv_cmd_dirty_bits { ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK = 1 << 6, /* VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK */ ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK = 1 << 7, /* VK_DYNAMIC_STATE_STENCIL_WRITE_MASK */ ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE = 1 << 8, /* VK_DYNAMIC_STATE_STENCIL_REFERENCE */ - ANV_CMD_DIRTY_DYNAMIC_ALL = (1 << 9) - 1, ANV_CMD_DIRTY_PIPELINE = 1 << 9, ANV_CMD_DIRTY_INDEX_BUFFER = 1 << 10, ANV_CMD_DIRTY_RENDER_TARGETS = 1 << 11, @@ -1955,6 +1954,46 @@ enum anv_cmd_dirty_bits { }; typedef uint32_t anv_cmd_dirty_mask_t; +#define ANV_CMD_DIRTY_DYNAMIC_ALL \ + (ANV_CMD_DIRTY_DYNAMIC_VIEWPORT | \ + ANV_CMD_DIRTY_DYNAMIC_SCISSOR | \ + ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH | \ + ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS | \ + ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS | \ + ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS | \ + ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK | \ + ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK | \ + ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE) + +static inline enum anv_cmd_dirty_bits +anv_cmd_dirty_bit_for_vk_dynamic_state(VkDynamicState vk_state) +{ + switch (vk_state) { + case VK_DYNAMIC_STATE_VIEWPORT: + return ANV_CMD_DIRTY_DYNAMIC_VIEWPORT; + case VK_DYNAMIC_STATE_SCISSOR: + return ANV_CMD_DIRTY_DYNAMIC_SCISSOR; + case VK_DYNAMIC_STATE_LINE_WIDTH: + return ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH; + case VK_DYNAMIC_STATE_DEPTH_BIAS: + return ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS; + case VK_DYNAMIC_STATE_BLEND_CONSTANTS: + return ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS; + case VK_DYNAMIC_STATE_DEPTH_BOUNDS: + return ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS; + case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: + return ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK; + case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: + return ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK; + case VK_DYNAMIC_STATE_STENCIL_REFERENCE: + return ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE; + default: + assert(!"Unsupported dynamic state"); + return 0; + } +} + + enum anv_pipe_bits { ANV_PIPE_DEPTH_CACHE_FLUSH_BIT = (1 << 0), ANV_PIPE_STALL_AT_SCOREBOARD_BIT = (1 << 1), @@ -2737,7 +2776,7 @@ struct anv_pipeline { struct anv_batch batch; uint32_t batch_data[512]; struct anv_reloc_list batch_relocs; - uint32_t dynamic_state_mask; + anv_cmd_dirty_mask_t dynamic_state_mask; struct anv_dynamic_state dynamic_state; struct anv_subpass * subpass; -- 2.30.2