X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_cmd_buffer.c;h=33687920a38e5ac1372d1492fba66f745439f330;hb=f270a0973741724d5bdddd30e4b241caa12a1c29;hp=b45f8f83757c64f6382e78143572493c6d0d92bd;hpb=79d403417cacd2728916e32ae55f4fc2a018515c;p=mesa.git diff --git a/src/intel/vulkan/anv_cmd_buffer.c b/src/intel/vulkan/anv_cmd_buffer.c index b45f8f83757..33687920a38 100644 --- a/src/intel/vulkan/anv_cmd_buffer.c +++ b/src/intel/vulkan/anv_cmd_buffer.c @@ -113,47 +113,44 @@ anv_dynamic_state_copy(struct anv_dynamic_state *dest, } static void -anv_cmd_state_reset(struct anv_cmd_buffer *cmd_buffer) +anv_cmd_state_init(struct anv_cmd_buffer *cmd_buffer) { struct anv_cmd_state *state = &cmd_buffer->state; - cmd_buffer->batch.status = VK_SUCCESS; + memset(state, 0, sizeof(*state)); - memset(&state->descriptors, 0, sizeof(state->descriptors)); - for (uint32_t i = 0; i < ARRAY_SIZE(state->push_descriptors); i++) { - vk_free(&cmd_buffer->pool->alloc, state->push_descriptors[i]); - state->push_descriptors[i] = NULL; - } - for (uint32_t i = 0; i < MESA_SHADER_STAGES; i++) { - vk_free(&cmd_buffer->pool->alloc, state->push_constants[i]); - state->push_constants[i] = NULL; - } - memset(state->binding_tables, 0, sizeof(state->binding_tables)); - memset(state->samplers, 0, sizeof(state->samplers)); - - /* 0 isn't a valid config. This ensures that we always configure L3$. */ - cmd_buffer->state.current_l3_config = 0; - - state->dirty = 0; - state->vb_dirty = 0; - state->pending_pipe_bits = 0; - state->descriptors_dirty = 0; - state->push_constants_dirty = 0; - state->pipeline = NULL; - state->framebuffer = NULL; - state->pass = NULL; - state->subpass = NULL; - state->push_constant_stages = 0; + state->current_pipeline = UINT32_MAX; state->restart_index = UINT32_MAX; - state->dynamic = default_dynamic_state; - state->need_query_wa = true; - state->pma_fix_enabled = false; - state->hiz_enabled = false; + state->gfx.dynamic = default_dynamic_state; +} + +static void +anv_cmd_pipeline_state_finish(struct anv_cmd_buffer *cmd_buffer, + struct anv_cmd_pipeline_state *pipe_state) +{ + for (uint32_t i = 0; i < ARRAY_SIZE(pipe_state->push_descriptors); i++) + vk_free(&cmd_buffer->pool->alloc, pipe_state->push_descriptors[i]); +} + +static void +anv_cmd_state_finish(struct anv_cmd_buffer *cmd_buffer) +{ + struct anv_cmd_state *state = &cmd_buffer->state; + + anv_cmd_pipeline_state_finish(cmd_buffer, &state->gfx.base); + anv_cmd_pipeline_state_finish(cmd_buffer, &state->compute.base); + + for (uint32_t i = 0; i < MESA_SHADER_STAGES; i++) + vk_free(&cmd_buffer->pool->alloc, state->push_constants[i]); vk_free(&cmd_buffer->pool->alloc, state->attachments); - state->attachments = NULL; +} - state->gen7.index_buffer = NULL; +static void +anv_cmd_state_reset(struct anv_cmd_buffer *cmd_buffer) +{ + anv_cmd_state_finish(cmd_buffer); + anv_cmd_state_init(cmd_buffer); } VkResult @@ -198,14 +195,10 @@ static VkResult anv_create_cmd_buffer( cmd_buffer->batch.status = VK_SUCCESS; - for (uint32_t i = 0; i < MESA_SHADER_STAGES; i++) { - cmd_buffer->state.push_constants[i] = NULL; - } cmd_buffer->_loader_data.loaderMagic = ICD_LOADER_MAGIC; cmd_buffer->device = device; cmd_buffer->pool = pool; cmd_buffer->level = level; - cmd_buffer->state.attachments = NULL; result = anv_cmd_buffer_init_batch_bo_chain(cmd_buffer); if (result != VK_SUCCESS) @@ -216,8 +209,7 @@ static VkResult anv_create_cmd_buffer( anv_state_stream_init(&cmd_buffer->dynamic_state_stream, &device->dynamic_state_pool, 16384); - memset(cmd_buffer->state.push_descriptors, 0, - sizeof(cmd_buffer->state.push_descriptors)); + anv_cmd_state_init(cmd_buffer); if (pool) { list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers); @@ -276,7 +268,7 @@ anv_cmd_buffer_destroy(struct anv_cmd_buffer *cmd_buffer) anv_state_stream_finish(&cmd_buffer->surface_state_stream); anv_state_stream_finish(&cmd_buffer->dynamic_state_stream); - anv_cmd_state_reset(cmd_buffer); + anv_cmd_state_finish(cmd_buffer); vk_free(&cmd_buffer->pool->alloc, cmd_buffer); } @@ -301,7 +293,6 @@ VkResult anv_cmd_buffer_reset(struct anv_cmd_buffer *cmd_buffer) { cmd_buffer->usage_flags = 0; - cmd_buffer->state.current_pipeline = UINT32_MAX; anv_cmd_buffer_reset_batch_bo_chain(cmd_buffer); anv_cmd_state_reset(cmd_buffer); @@ -323,24 +314,52 @@ VkResult anv_ResetCommandBuffer( return anv_cmd_buffer_reset(cmd_buffer); } +#define anv_genX_call(devinfo, func, ...) \ + switch ((devinfo)->gen) { \ + case 7: \ + if ((devinfo)->is_haswell) { \ + gen75_##func(__VA_ARGS__); \ + } else { \ + gen7_##func(__VA_ARGS__); \ + } \ + break; \ + case 8: \ + gen8_##func(__VA_ARGS__); \ + break; \ + case 9: \ + gen9_##func(__VA_ARGS__); \ + break; \ + case 10: \ + gen10_##func(__VA_ARGS__); \ + break; \ + case 11: \ + gen11_##func(__VA_ARGS__); \ + break; \ + default: \ + assert(!"Unknown hardware generation"); \ + } + void anv_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer) { - switch (cmd_buffer->device->info.gen) { - case 7: - if (cmd_buffer->device->info.is_haswell) - return gen75_cmd_buffer_emit_state_base_address(cmd_buffer); - else - return gen7_cmd_buffer_emit_state_base_address(cmd_buffer); - case 8: - return gen8_cmd_buffer_emit_state_base_address(cmd_buffer); - case 9: - return gen9_cmd_buffer_emit_state_base_address(cmd_buffer); - case 10: - return gen10_cmd_buffer_emit_state_base_address(cmd_buffer); - default: - unreachable("unsupported gen\n"); - } + anv_genX_call(&cmd_buffer->device->info, + cmd_buffer_emit_state_base_address, + cmd_buffer); +} + +void +anv_cmd_buffer_mark_image_written(struct anv_cmd_buffer *cmd_buffer, + const struct anv_image *image, + VkImageAspectFlagBits aspect, + enum isl_aux_usage aux_usage, + uint32_t level, + uint32_t base_layer, + uint32_t layer_count) +{ + anv_genX_call(&cmd_buffer->device->info, + cmd_buffer_mark_image_written, + cmd_buffer, image, aspect, aux_usage, + level, base_layer, layer_count); } void anv_CmdBindPipeline( @@ -353,22 +372,22 @@ void anv_CmdBindPipeline( switch (pipelineBindPoint) { case VK_PIPELINE_BIND_POINT_COMPUTE: - cmd_buffer->state.compute_pipeline = pipeline; - cmd_buffer->state.compute_dirty |= ANV_CMD_DIRTY_PIPELINE; + cmd_buffer->state.compute.base.pipeline = pipeline; + cmd_buffer->state.compute.pipeline_dirty = true; cmd_buffer->state.push_constants_dirty |= VK_SHADER_STAGE_COMPUTE_BIT; cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_COMPUTE_BIT; break; case VK_PIPELINE_BIND_POINT_GRAPHICS: - cmd_buffer->state.pipeline = pipeline; - cmd_buffer->state.vb_dirty |= pipeline->vb_used; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_PIPELINE; + cmd_buffer->state.gfx.base.pipeline = pipeline; + cmd_buffer->state.gfx.vb_dirty |= pipeline->vb_used; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_PIPELINE; cmd_buffer->state.push_constants_dirty |= pipeline->active_stages; cmd_buffer->state.descriptors_dirty |= pipeline->active_stages; /* Apply the dynamic state from the pipeline */ - cmd_buffer->state.dirty |= pipeline->dynamic_state_mask; - anv_dynamic_state_copy(&cmd_buffer->state.dynamic, + cmd_buffer->state.gfx.dirty |= pipeline->dynamic_state_mask; + anv_dynamic_state_copy(&cmd_buffer->state.gfx.dynamic, &pipeline->dynamic_state, pipeline->dynamic_state_mask); break; @@ -388,13 +407,13 @@ void anv_CmdSetViewport( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); const uint32_t total_count = firstViewport + viewportCount; - if (cmd_buffer->state.dynamic.viewport.count < total_count) - cmd_buffer->state.dynamic.viewport.count = total_count; + if (cmd_buffer->state.gfx.dynamic.viewport.count < total_count) + cmd_buffer->state.gfx.dynamic.viewport.count = total_count; - memcpy(cmd_buffer->state.dynamic.viewport.viewports + firstViewport, + memcpy(cmd_buffer->state.gfx.dynamic.viewport.viewports + firstViewport, pViewports, viewportCount * sizeof(*pViewports)); - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_VIEWPORT; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_VIEWPORT; } void anv_CmdSetScissor( @@ -406,13 +425,13 @@ void anv_CmdSetScissor( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); const uint32_t total_count = firstScissor + scissorCount; - if (cmd_buffer->state.dynamic.scissor.count < total_count) - cmd_buffer->state.dynamic.scissor.count = total_count; + if (cmd_buffer->state.gfx.dynamic.scissor.count < total_count) + cmd_buffer->state.gfx.dynamic.scissor.count = total_count; - memcpy(cmd_buffer->state.dynamic.scissor.scissors + firstScissor, + memcpy(cmd_buffer->state.gfx.dynamic.scissor.scissors + firstScissor, pScissors, scissorCount * sizeof(*pScissors)); - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_SCISSOR; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_SCISSOR; } void anv_CmdSetLineWidth( @@ -421,8 +440,8 @@ void anv_CmdSetLineWidth( { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); - cmd_buffer->state.dynamic.line_width = lineWidth; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH; + cmd_buffer->state.gfx.dynamic.line_width = lineWidth; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_LINE_WIDTH; } void anv_CmdSetDepthBias( @@ -433,11 +452,11 @@ void anv_CmdSetDepthBias( { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); - cmd_buffer->state.dynamic.depth_bias.bias = depthBiasConstantFactor; - cmd_buffer->state.dynamic.depth_bias.clamp = depthBiasClamp; - cmd_buffer->state.dynamic.depth_bias.slope = depthBiasSlopeFactor; + cmd_buffer->state.gfx.dynamic.depth_bias.bias = depthBiasConstantFactor; + cmd_buffer->state.gfx.dynamic.depth_bias.clamp = depthBiasClamp; + cmd_buffer->state.gfx.dynamic.depth_bias.slope = depthBiasSlopeFactor; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_DEPTH_BIAS; } void anv_CmdSetBlendConstants( @@ -446,10 +465,10 @@ void anv_CmdSetBlendConstants( { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); - memcpy(cmd_buffer->state.dynamic.blend_constants, + memcpy(cmd_buffer->state.gfx.dynamic.blend_constants, blendConstants, sizeof(float) * 4); - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_BLEND_CONSTANTS; } void anv_CmdSetDepthBounds( @@ -459,10 +478,10 @@ void anv_CmdSetDepthBounds( { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); - cmd_buffer->state.dynamic.depth_bounds.min = minDepthBounds; - cmd_buffer->state.dynamic.depth_bounds.max = maxDepthBounds; + cmd_buffer->state.gfx.dynamic.depth_bounds.min = minDepthBounds; + cmd_buffer->state.gfx.dynamic.depth_bounds.max = maxDepthBounds; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_DEPTH_BOUNDS; } void anv_CmdSetStencilCompareMask( @@ -473,11 +492,11 @@ void anv_CmdSetStencilCompareMask( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); if (faceMask & VK_STENCIL_FACE_FRONT_BIT) - cmd_buffer->state.dynamic.stencil_compare_mask.front = compareMask; + cmd_buffer->state.gfx.dynamic.stencil_compare_mask.front = compareMask; if (faceMask & VK_STENCIL_FACE_BACK_BIT) - cmd_buffer->state.dynamic.stencil_compare_mask.back = compareMask; + cmd_buffer->state.gfx.dynamic.stencil_compare_mask.back = compareMask; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_COMPARE_MASK; } void anv_CmdSetStencilWriteMask( @@ -488,11 +507,11 @@ void anv_CmdSetStencilWriteMask( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); if (faceMask & VK_STENCIL_FACE_FRONT_BIT) - cmd_buffer->state.dynamic.stencil_write_mask.front = writeMask; + cmd_buffer->state.gfx.dynamic.stencil_write_mask.front = writeMask; if (faceMask & VK_STENCIL_FACE_BACK_BIT) - cmd_buffer->state.dynamic.stencil_write_mask.back = writeMask; + cmd_buffer->state.gfx.dynamic.stencil_write_mask.back = writeMask; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_WRITE_MASK; } void anv_CmdSetStencilReference( @@ -503,11 +522,67 @@ void anv_CmdSetStencilReference( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); if (faceMask & VK_STENCIL_FACE_FRONT_BIT) - cmd_buffer->state.dynamic.stencil_reference.front = reference; + cmd_buffer->state.gfx.dynamic.stencil_reference.front = reference; if (faceMask & VK_STENCIL_FACE_BACK_BIT) - cmd_buffer->state.dynamic.stencil_reference.back = reference; + cmd_buffer->state.gfx.dynamic.stencil_reference.back = reference; - cmd_buffer->state.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE; + cmd_buffer->state.gfx.dirty |= ANV_CMD_DIRTY_DYNAMIC_STENCIL_REFERENCE; +} + +static void +anv_cmd_buffer_bind_descriptor_set(struct anv_cmd_buffer *cmd_buffer, + VkPipelineBindPoint bind_point, + struct anv_pipeline_layout *layout, + uint32_t set_index, + struct anv_descriptor_set *set, + uint32_t *dynamic_offset_count, + const uint32_t **dynamic_offsets) +{ + struct anv_descriptor_set_layout *set_layout = + layout->set[set_index].layout; + + struct anv_cmd_pipeline_state *pipe_state; + if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { + pipe_state = &cmd_buffer->state.compute.base; + } else { + assert(bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS); + pipe_state = &cmd_buffer->state.gfx.base; + } + pipe_state->descriptors[set_index] = set; + + if (dynamic_offsets) { + if (set_layout->dynamic_offset_count > 0) { + uint32_t dynamic_offset_start = + layout->set[set_index].dynamic_offset_start; + + /* Assert that everything is in range */ + assert(set_layout->dynamic_offset_count <= *dynamic_offset_count); + assert(dynamic_offset_start + set_layout->dynamic_offset_count <= + ARRAY_SIZE(pipe_state->dynamic_offsets)); + + typed_memcpy(&pipe_state->dynamic_offsets[dynamic_offset_start], + *dynamic_offsets, set_layout->dynamic_offset_count); + + *dynamic_offsets += set_layout->dynamic_offset_count; + *dynamic_offset_count -= set_layout->dynamic_offset_count; + } + } + + if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { + cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_COMPUTE_BIT; + } else { + assert(bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS); + cmd_buffer->state.descriptors_dirty |= + set_layout->shader_stages & VK_SHADER_STAGE_ALL_GRAPHICS; + } + + /* Pipeline layout objects are required to live at least while any command + * buffers that use them are in recording state. We need to grab a reference + * to the pipeline layout being bound here so we can compute correct dynamic + * offsets for VK_DESCRIPTOR_TYPE_*_DYNAMIC in dynamic_offset_for_binding() + * when we record draw commands that come after this. + */ + pipe_state->layout = layout; } void anv_CmdBindDescriptorSets( @@ -522,35 +597,15 @@ void anv_CmdBindDescriptorSets( { ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); ANV_FROM_HANDLE(anv_pipeline_layout, layout, _layout); - struct anv_descriptor_set_layout *set_layout; assert(firstSet + descriptorSetCount < MAX_SETS); - uint32_t dynamic_slot = 0; for (uint32_t i = 0; i < descriptorSetCount; i++) { ANV_FROM_HANDLE(anv_descriptor_set, set, pDescriptorSets[i]); - set_layout = layout->set[firstSet + i].layout; - - cmd_buffer->state.descriptors[firstSet + i] = set; - - if (set_layout->dynamic_offset_count > 0) { - uint32_t dynamic_offset_start = - layout->set[firstSet + i].dynamic_offset_start; - - /* Assert that everything is in range */ - assert(dynamic_offset_start + set_layout->dynamic_offset_count <= - ARRAY_SIZE(cmd_buffer->state.dynamic_offsets)); - assert(dynamic_slot + set_layout->dynamic_offset_count <= - dynamicOffsetCount); - - typed_memcpy(&cmd_buffer->state.dynamic_offsets[dynamic_offset_start], - &pDynamicOffsets[dynamic_slot], - set_layout->dynamic_offset_count); - - dynamic_slot += set_layout->dynamic_offset_count; - } - - cmd_buffer->state.descriptors_dirty |= set_layout->shader_stages; + anv_cmd_buffer_bind_descriptor_set(cmd_buffer, pipelineBindPoint, + layout, firstSet + i, set, + &dynamicOffsetCount, + &pDynamicOffsets); } } @@ -571,7 +626,7 @@ void anv_CmdBindVertexBuffers( for (uint32_t i = 0; i < bindingCount; i++) { vb[firstBinding + i].buffer = anv_buffer_from_handle(pBuffers[i]); vb[firstBinding + i].offset = pOffsets[i]; - cmd_buffer->state.vb_dirty |= 1 << (firstBinding + i); + cmd_buffer->state.gfx.vb_dirty |= 1 << (firstBinding + i); } } @@ -636,6 +691,12 @@ anv_push_constant_value(struct anv_push_constants *data, uint32_t param) switch (param) { case BRW_PARAM_BUILTIN_ZERO: return 0; + case BRW_PARAM_BUILTIN_BASE_WORK_GROUP_ID_X: + return data->base_work_group_id[0]; + case BRW_PARAM_BUILTIN_BASE_WORK_GROUP_ID_Y: + return data->base_work_group_id[1]; + case BRW_PARAM_BUILTIN_BASE_WORK_GROUP_ID_Z: + return data->base_work_group_id[2]; default: unreachable("Invalid param builtin"); } @@ -653,14 +714,16 @@ struct anv_state anv_cmd_buffer_push_constants(struct anv_cmd_buffer *cmd_buffer, gl_shader_stage stage) { + struct anv_pipeline *pipeline = cmd_buffer->state.gfx.base.pipeline; + /* If we don't have this stage, bail. */ - if (!anv_pipeline_has_stage(cmd_buffer->state.pipeline, stage)) + if (!anv_pipeline_has_stage(pipeline, stage)) return (struct anv_state) { .offset = 0 }; struct anv_push_constants *data = cmd_buffer->state.push_constants[stage]; const struct brw_stage_prog_data *prog_data = - cmd_buffer->state.pipeline->shaders[stage]->prog_data; + pipeline->shaders[stage]->prog_data; /* If we don't actually have any push constants, bail. */ if (data == NULL || prog_data == NULL || prog_data->nr_params == 0) @@ -686,7 +749,7 @@ anv_cmd_buffer_cs_push_constants(struct anv_cmd_buffer *cmd_buffer) { struct anv_push_constants *data = cmd_buffer->state.push_constants[MESA_SHADER_COMPUTE]; - struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; + struct anv_pipeline *pipeline = cmd_buffer->state.compute.base.pipeline; const struct brw_cs_prog_data *cs_prog_data = get_cs_prog_data(pipeline); const struct brw_stage_prog_data *prog_data = &cs_prog_data->base; @@ -710,7 +773,7 @@ anv_cmd_buffer_cs_push_constants(struct anv_cmd_buffer *cmd_buffer) for (unsigned i = 0; i < cs_prog_data->push.cross_thread.dwords; i++) { - assert(prog_data->param[i] != BRW_PARAM_BUILTIN_THREAD_LOCAL_ID); + assert(prog_data->param[i] != BRW_PARAM_BUILTIN_SUBGROUP_ID); u32_map[i] = anv_push_constant_value(data, prog_data->param[i]); } } @@ -722,8 +785,8 @@ anv_cmd_buffer_cs_push_constants(struct anv_cmd_buffer *cmd_buffer) cs_prog_data->push.cross_thread.regs); unsigned src = cs_prog_data->push.cross_thread.dwords; for ( ; src < prog_data->nr_params; src++, dst++) { - if (prog_data->param[src] == BRW_PARAM_BUILTIN_THREAD_LOCAL_ID) { - u32_map[dst] = t * cs_prog_data->simd_size; + if (prog_data->param[src] == BRW_PARAM_BUILTIN_SUBGROUP_ID) { + u32_map[dst] = t; } else { u32_map[dst] = anv_push_constant_value(data, prog_data->param[src]); @@ -821,10 +884,10 @@ VkResult anv_ResetCommandPool( return VK_SUCCESS; } -void anv_TrimCommandPoolKHR( +void anv_TrimCommandPool( VkDevice device, VkCommandPool commandPool, - VkCommandPoolTrimFlagsKHR flags) + VkCommandPoolTrimFlags flags) { /* Nothing for us to do here. Our pools stay pretty tidy. */ } @@ -850,12 +913,21 @@ anv_cmd_buffer_get_depth_stencil_view(const struct anv_cmd_buffer *cmd_buffer) return iview; } -static VkResult -anv_cmd_buffer_ensure_push_descriptor_set(struct anv_cmd_buffer *cmd_buffer, - uint32_t set) +static struct anv_push_descriptor_set * +anv_cmd_buffer_get_push_descriptor_set(struct anv_cmd_buffer *cmd_buffer, + VkPipelineBindPoint bind_point, + uint32_t set) { + struct anv_cmd_pipeline_state *pipe_state; + if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { + pipe_state = &cmd_buffer->state.compute.base; + } else { + assert(bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS); + pipe_state = &cmd_buffer->state.gfx.base; + } + struct anv_push_descriptor_set **push_set = - &cmd_buffer->state.push_descriptors[set]; + &pipe_state->push_descriptors[set]; if (*push_set == NULL) { *push_set = vk_alloc(&cmd_buffer->pool->alloc, @@ -863,11 +935,11 @@ anv_cmd_buffer_ensure_push_descriptor_set(struct anv_cmd_buffer *cmd_buffer, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (*push_set == NULL) { anv_batch_set_error(&cmd_buffer->batch, VK_ERROR_OUT_OF_HOST_MEMORY); - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + return NULL; } } - return VK_SUCCESS; + return *push_set; } void anv_CmdPushDescriptorSetKHR( @@ -881,17 +953,16 @@ void anv_CmdPushDescriptorSetKHR( ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); ANV_FROM_HANDLE(anv_pipeline_layout, layout, _layout); - assert(pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS || - pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE); assert(_set < MAX_SETS); - const struct anv_descriptor_set_layout *set_layout = - layout->set[_set].layout; + struct anv_descriptor_set_layout *set_layout = layout->set[_set].layout; - if (anv_cmd_buffer_ensure_push_descriptor_set(cmd_buffer, _set) != VK_SUCCESS) - return; struct anv_push_descriptor_set *push_set = - cmd_buffer->state.push_descriptors[_set]; + anv_cmd_buffer_get_push_descriptor_set(cmd_buffer, + pipelineBindPoint, _set); + if (!push_set) + return; + struct anv_descriptor_set *set = &push_set->set; set->layout = set_layout; @@ -958,13 +1029,13 @@ void anv_CmdPushDescriptorSetKHR( } } - cmd_buffer->state.descriptors[_set] = set; - cmd_buffer->state.descriptors_dirty |= set_layout->shader_stages; + anv_cmd_buffer_bind_descriptor_set(cmd_buffer, pipelineBindPoint, + layout, _set, set, NULL, NULL); } void anv_CmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout _layout, uint32_t _set, const void* pData) @@ -976,13 +1047,14 @@ void anv_CmdPushDescriptorSetWithTemplateKHR( assert(_set < MAX_PUSH_DESCRIPTORS); - const struct anv_descriptor_set_layout *set_layout = - layout->set[_set].layout; + struct anv_descriptor_set_layout *set_layout = layout->set[_set].layout; - if (anv_cmd_buffer_ensure_push_descriptor_set(cmd_buffer, _set) != VK_SUCCESS) - return; struct anv_push_descriptor_set *push_set = - cmd_buffer->state.push_descriptors[_set]; + anv_cmd_buffer_get_push_descriptor_set(cmd_buffer, + template->bind_point, _set); + if (!push_set) + return; + struct anv_descriptor_set *set = &push_set->set; set->layout = set_layout; @@ -996,6 +1068,13 @@ void anv_CmdPushDescriptorSetWithTemplateKHR( template, pData); - cmd_buffer->state.descriptors[_set] = set; - cmd_buffer->state.descriptors_dirty |= set_layout->shader_stages; + anv_cmd_buffer_bind_descriptor_set(cmd_buffer, template->bind_point, + layout, _set, set, NULL, NULL); +} + +void anv_CmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ + /* No-op */ }