[Mesa-dev] [PATCH] radv: fix multisample image copies

Samuel Pitoiset samuel.pitoiset at gmail.com
Thu Apr 19 07:06:08 UTC 2018



On 04/18/2018 11:56 PM, Dave Airlie wrote:
> On 18 April 2018 at 00:31, Matthew Nicholls
> <mnicholls at feralinteractive.com> wrote:
>> Previously before fb077b0728, the LOD parameter was being used in place of the
>> sample index, which would only copy the first sample to all samples in the
>> destination image. After that multisample image copies wouldn't copy anything
>> from my observations.
>>
>> Fix this properly by copying each sample in a separate radv_CmdDraw and using a
>> pipeline with the correct rasterizationSamples for the destination image.
> 
> Have you run CTS on this?
> 
> I wrote something similiar (I'm on holidays at the moment so can't
> confirm how similiar)
> but it failed some CTS tests for me.

I did run CTS on this, but no changes.

> 
> Dave.
> 
>> ---
>>   src/amd/vulkan/radv_meta_blit2d.c | 279 ++++++++++++++++++++++++--------------
>>   src/amd/vulkan/radv_private.h     |  18 +--
>>   2 files changed, 189 insertions(+), 108 deletions(-)
>>
>> diff --git a/src/amd/vulkan/radv_meta_blit2d.c b/src/amd/vulkan/radv_meta_blit2d.c
>> index e163056257..d953241b55 100644
>> --- a/src/amd/vulkan/radv_meta_blit2d.c
>> +++ b/src/amd/vulkan/radv_meta_blit2d.c
>> @@ -100,7 +100,8 @@ blit2d_bind_src(struct radv_cmd_buffer *cmd_buffer,
>>                   struct radv_meta_blit2d_buffer *src_buf,
>>                   struct blit2d_src_temps *tmp,
>>                   enum blit2d_src_type src_type, VkFormat depth_format,
>> -                VkImageAspectFlagBits aspects)
>> +                VkImageAspectFlagBits aspects,
>> +                uint32_t log2_samples)
>>   {
>>          struct radv_device *device = cmd_buffer->device;
>>
>> @@ -108,7 +109,7 @@ blit2d_bind_src(struct radv_cmd_buffer *cmd_buffer,
>>                  create_bview(cmd_buffer, src_buf, &tmp->bview, depth_format);
>>
>>                  radv_meta_push_descriptor_set(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
>> -                                             device->meta_state.blit2d.p_layouts[src_type],
>> +                                             device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>>                                                0, /* set */
>>                                                1, /* descriptorWriteCount */
>>                                                (VkWriteDescriptorSet[]) {
>> @@ -123,7 +124,7 @@ blit2d_bind_src(struct radv_cmd_buffer *cmd_buffer,
>>                                                });
>>
>>                  radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
>> -                                     device->meta_state.blit2d.p_layouts[src_type],
>> +                                     device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>>                                        VK_SHADER_STAGE_FRAGMENT_BIT, 16, 4,
>>                                        &src_buf->pitch);
>>          } else {
>> @@ -131,12 +132,12 @@ blit2d_bind_src(struct radv_cmd_buffer *cmd_buffer,
>>
>>                  if (src_type == BLIT2D_SRC_TYPE_IMAGE_3D)
>>                          radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
>> -                                             device->meta_state.blit2d.p_layouts[src_type],
>> +                                             device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>>                                                VK_SHADER_STAGE_FRAGMENT_BIT, 16, 4,
>>                                                &src_img->layer);
>>
>>                  radv_meta_push_descriptor_set(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
>> -                                             device->meta_state.blit2d.p_layouts[src_type],
>> +                                             device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>>                                                0, /* set */
>>                                                1, /* descriptorWriteCount */
>>                                                (VkWriteDescriptorSet[]) {
>> @@ -190,10 +191,11 @@ blit2d_bind_dst(struct radv_cmd_buffer *cmd_buffer,
>>
>>   static void
>>   bind_pipeline(struct radv_cmd_buffer *cmd_buffer,
>> -              enum blit2d_src_type src_type, unsigned fs_key)
>> +              enum blit2d_src_type src_type, unsigned fs_key,
>> +              uint32_t log2_samples)
>>   {
>>          VkPipeline pipeline =
>> -               cmd_buffer->device->meta_state.blit2d.pipelines[src_type][fs_key];
>> +               cmd_buffer->device->meta_state.blit2d[log2_samples].pipelines[src_type][fs_key];
>>
>>          radv_CmdBindPipeline(radv_cmd_buffer_to_handle(cmd_buffer),
>>                               VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
>> @@ -201,10 +203,11 @@ bind_pipeline(struct radv_cmd_buffer *cmd_buffer,
>>
>>   static void
>>   bind_depth_pipeline(struct radv_cmd_buffer *cmd_buffer,
>> -                   enum blit2d_src_type src_type)
>> +                   enum blit2d_src_type src_type,
>> +                   uint32_t log2_samples)
>>   {
>>          VkPipeline pipeline =
>> -               cmd_buffer->device->meta_state.blit2d.depth_only_pipeline[src_type];
>> +               cmd_buffer->device->meta_state.blit2d[log2_samples].depth_only_pipeline[src_type];
>>
>>          radv_CmdBindPipeline(radv_cmd_buffer_to_handle(cmd_buffer),
>>                               VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
>> @@ -212,10 +215,11 @@ bind_depth_pipeline(struct radv_cmd_buffer *cmd_buffer,
>>
>>   static void
>>   bind_stencil_pipeline(struct radv_cmd_buffer *cmd_buffer,
>> -                     enum blit2d_src_type src_type)
>> +                     enum blit2d_src_type src_type,
>> +                     uint32_t log2_samples)
>>   {
>>          VkPipeline pipeline =
>> -               cmd_buffer->device->meta_state.blit2d.stencil_only_pipeline[src_type];
>> +               cmd_buffer->device->meta_state.blit2d[log2_samples].stencil_only_pipeline[src_type];
>>
>>          radv_CmdBindPipeline(radv_cmd_buffer_to_handle(cmd_buffer),
>>                               VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
>> @@ -227,7 +231,8 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                              struct radv_meta_blit2d_buffer *src_buf,
>>                              struct radv_meta_blit2d_surf *dst,
>>                              unsigned num_rects,
>> -                           struct radv_meta_blit2d_rect *rects, enum blit2d_src_type src_type)
>> +                           struct radv_meta_blit2d_rect *rects, enum blit2d_src_type src_type,
>> +                           uint32_t log2_samples)
>>   {
>>          struct radv_device *device = cmd_buffer->device;
>>
>> @@ -241,7 +246,7 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                          else if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT)
>>                                  depth_format = vk_format_depth_only(dst->image->vk_format);
>>                          struct blit2d_src_temps src_temps;
>> -                       blit2d_bind_src(cmd_buffer, src_img, src_buf, &src_temps, src_type, depth_format, aspect_mask);
>> +                       blit2d_bind_src(cmd_buffer, src_img, src_buf, &src_temps, src_type, depth_format, aspect_mask, log2_samples);
>>
>>                          struct blit2d_dst_temps dst_temps;
>>                          blit2d_bind_dst(cmd_buffer, dst, rects[r].dst_x + rects[r].width,
>> @@ -255,7 +260,7 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                          };
>>
>>                          radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
>> -                                       device->meta_state.blit2d.p_layouts[src_type],
>> +                                       device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>>                                          VK_SHADER_STAGE_VERTEX_BIT, 0, 16,
>>                                          vertex_push_constants);
>>
>> @@ -266,7 +271,7 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                                  radv_CmdBeginRenderPass(radv_cmd_buffer_to_handle(cmd_buffer),
>>                                                          &(VkRenderPassBeginInfo) {
>>                                                                  .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
>> -                                                                       .renderPass = device->meta_state.blit2d.render_passes[fs_key][dst_layout],
>> +                                                                       .renderPass = device->meta_state.blit2d_render_passes[fs_key][dst_layout],
>>                                                                          .framebuffer = dst_temps.fb,
>>                                                                          .renderArea = {
>>                                                                          .offset = { rects[r].dst_x, rects[r].dst_y, },
>> @@ -277,13 +282,13 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                                                                                  }, VK_SUBPASS_CONTENTS_INLINE);
>>
>>
>> -                               bind_pipeline(cmd_buffer, src_type, fs_key);
>> +                               bind_pipeline(cmd_buffer, src_type, fs_key, log2_samples);
>>                          } else if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT) {
>>                                  enum radv_blit_ds_layout ds_layout = radv_meta_blit_ds_to_type(dst->current_layout);
>>                                  radv_CmdBeginRenderPass(radv_cmd_buffer_to_handle(cmd_buffer),
>>                                                          &(VkRenderPassBeginInfo) {
>>                                                                  .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
>> -                                                                       .renderPass = device->meta_state.blit2d.depth_only_rp[ds_layout],
>> +                                                                       .renderPass = device->meta_state.blit2d_depth_only_rp[ds_layout],
>>                                                                          .framebuffer = dst_temps.fb,
>>                                                                          .renderArea = {
>>                                                                          .offset = { rects[r].dst_x, rects[r].dst_y, },
>> @@ -294,14 +299,14 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                                                                                  }, VK_SUBPASS_CONTENTS_INLINE);
>>
>>
>> -                               bind_depth_pipeline(cmd_buffer, src_type);
>> +                               bind_depth_pipeline(cmd_buffer, src_type, log2_samples);
>>
>>                          } else if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) {
>>                                  enum radv_blit_ds_layout ds_layout = radv_meta_blit_ds_to_type(dst->current_layout);
>>                                  radv_CmdBeginRenderPass(radv_cmd_buffer_to_handle(cmd_buffer),
>>                                                          &(VkRenderPassBeginInfo) {
>>                                                                  .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
>> -                                                                       .renderPass = device->meta_state.blit2d.stencil_only_rp[ds_layout],
>> +                                                                       .renderPass = device->meta_state.blit2d_stencil_only_rp[ds_layout],
>>                                                                          .framebuffer = dst_temps.fb,
>>                                                                          .renderArea = {
>>                                                                          .offset = { rects[r].dst_x, rects[r].dst_y, },
>> @@ -312,7 +317,7 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>                                                                                  }, VK_SUBPASS_CONTENTS_INLINE);
>>
>>
>> -                               bind_stencil_pipeline(cmd_buffer, src_type);
>> +                               bind_stencil_pipeline(cmd_buffer, src_type, log2_samples);
>>                          } else
>>                                  unreachable("Processing blit2d with multiple aspects.");
>>
>> @@ -332,7 +337,24 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer *cmd_buffer,
>>
>>
>>
>> -                       radv_CmdDraw(radv_cmd_buffer_to_handle(cmd_buffer), 3, 1, 0, 0);
>> +                       if (log2_samples > 0) {
>> +                               for (uint32_t sample = 0; sample < src_img->image->info.samples; sample++) {
>> +                                       uint32_t sample_mask = 1 << sample;
>> +                                       radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
>> +                                                             device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>> +                                                             VK_SHADER_STAGE_FRAGMENT_BIT, 20, 4,
>> +                                                             &sample);
>> +
>> +                                       radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
>> +                                                             device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>> +                                                             VK_SHADER_STAGE_FRAGMENT_BIT, 24, 4,
>> +                                                             &sample_mask);
>> +
>> +                                       radv_CmdDraw(radv_cmd_buffer_to_handle(cmd_buffer), 3, 1, 0, 0);
>> +                               }
>> +                       }
>> +                       else
>> +                               radv_CmdDraw(radv_cmd_buffer_to_handle(cmd_buffer), 3, 1, 0, 0);
>>                          radv_CmdEndRenderPass(radv_cmd_buffer_to_handle(cmd_buffer));
>>
>>                          /* At the point where we emit the draw call, all data from the
>> @@ -358,7 +380,8 @@ radv_meta_blit2d(struct radv_cmd_buffer *cmd_buffer,
>>          enum blit2d_src_type src_type = src_buf ? BLIT2D_SRC_TYPE_BUFFER :
>>                  use_3d ? BLIT2D_SRC_TYPE_IMAGE_3D : BLIT2D_SRC_TYPE_IMAGE;
>>          radv_meta_blit2d_normal_dst(cmd_buffer, src_img, src_buf, dst,
>> -                                   num_rects, rects, src_type);
>> +                                   num_rects, rects, src_type,
>> +                                   src_img ? util_logbase2(src_img->image->info.samples) : 0);
>>   }
>>
>>   static nir_shader *
>> @@ -421,11 +444,11 @@ build_nir_vertex_shader(void)
>>
>>   typedef nir_ssa_def* (*texel_fetch_build_func)(struct nir_builder *,
>>                                                  struct radv_device *,
>> -                                               nir_ssa_def *, bool);
>> +                                               nir_ssa_def *, bool, bool);
>>
>>   static nir_ssa_def *
>>   build_nir_texel_fetch(struct nir_builder *b, struct radv_device *device,
>> -                      nir_ssa_def *tex_pos, bool is_3d)
>> +                      nir_ssa_def *tex_pos, bool is_3d, bool is_multisampled)
>>   {
>>          enum glsl_sampler_dim dim = is_3d ? GLSL_SAMPLER_DIM_3D : GLSL_SAMPLER_DIM_2D;
>>          const struct glsl_type *sampler_type =
>> @@ -436,6 +459,7 @@ build_nir_texel_fetch(struct nir_builder *b, struct radv_device *device,
>>          sampler->data.binding = 0;
>>
>>          nir_ssa_def *tex_pos_3d = NULL;
>> +       nir_intrinsic_instr *sample_idx = NULL;
>>          if (is_3d) {
>>                  nir_intrinsic_instr *layer = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_push_constant);
>>                  nir_intrinsic_set_base(layer, 16);
>> @@ -451,13 +475,22 @@ build_nir_texel_fetch(struct nir_builder *b, struct radv_device *device,
>>                  chans[2] = &layer->dest.ssa;
>>                  tex_pos_3d = nir_vec(b, chans, 3);
>>          }
>> +       if (is_multisampled) {
>> +               sample_idx = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_push_constant);
>> +               nir_intrinsic_set_base(sample_idx, 20);
>> +               nir_intrinsic_set_range(sample_idx, 4);
>> +               sample_idx->src[0] = nir_src_for_ssa(nir_imm_int(b, 0));
>> +               sample_idx->num_components = 1;
>> +               nir_ssa_dest_init(&sample_idx->instr, &sample_idx->dest, 1, 32, "sample_idx");
>> +               nir_builder_instr_insert(b, &sample_idx->instr);
>> +       }
>>          nir_tex_instr *tex = nir_tex_instr_create(b->shader, 2);
>>          tex->sampler_dim = dim;
>> -       tex->op = nir_texop_txf;
>> +       tex->op = is_multisampled ? nir_texop_txf_ms : nir_texop_txf;
>>          tex->src[0].src_type = nir_tex_src_coord;
>>          tex->src[0].src = nir_src_for_ssa(is_3d ? tex_pos_3d : tex_pos);
>> -       tex->src[1].src_type = nir_tex_src_lod;
>> -       tex->src[1].src = nir_src_for_ssa(nir_imm_int(b, 0));
>> +       tex->src[1].src_type = is_multisampled ? nir_tex_src_ms_index : nir_tex_src_lod;
>> +       tex->src[1].src = nir_src_for_ssa(is_multisampled ? &sample_idx->dest.ssa : nir_imm_int(b, 0));
>>          tex->dest_type = nir_type_uint;
>>          tex->is_array = false;
>>          tex->coord_components = is_3d ? 3 : 2;
>> @@ -473,7 +506,7 @@ build_nir_texel_fetch(struct nir_builder *b, struct radv_device *device,
>>
>>   static nir_ssa_def *
>>   build_nir_buffer_fetch(struct nir_builder *b, struct radv_device *device,
>> -                      nir_ssa_def *tex_pos, bool is_3d)
>> +                      nir_ssa_def *tex_pos, bool is_3d, bool is_multisampled)
>>   {
>>          const struct glsl_type *sampler_type =
>>                  glsl_sampler_type(GLSL_SAMPLER_DIM_BUF, false, false, GLSL_TYPE_UINT);
>> @@ -519,9 +552,31 @@ static const VkPipelineVertexInputStateCreateInfo normal_vi_create_info = {
>>          .vertexAttributeDescriptionCount = 0,
>>   };
>>
>> +static void
>> +build_nir_store_sample_mask(struct nir_builder *b)
>> +{
>> +       nir_intrinsic_instr *sample_mask = nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_push_constant);
>> +       nir_intrinsic_set_base(sample_mask, 24);
>> +       nir_intrinsic_set_range(sample_mask, 4);
>> +       sample_mask->src[0] = nir_src_for_ssa(nir_imm_int(b, 0));
>> +       sample_mask->num_components = 1;
>> +       nir_ssa_dest_init(&sample_mask->instr, &sample_mask->dest, 1, 32, "sample_mask");
>> +       nir_builder_instr_insert(b, &sample_mask->instr);
>> +
>> +       const struct glsl_type *sample_mask_out_type = glsl_uint_type();
>> +
>> +       nir_variable *sample_mask_out =
>> +               nir_variable_create(b->shader, nir_var_shader_out,
>> +                                   sample_mask_out_type, "sample_mask_out");
>> +       sample_mask_out->data.location = FRAG_RESULT_SAMPLE_MASK;
>> +
>> +       nir_store_var(b, sample_mask_out, &sample_mask->dest.ssa, 0x1);
>> +}
>> +
>>   static nir_shader *
>>   build_nir_copy_fragment_shader(struct radv_device *device,
>> -                               texel_fetch_build_func txf_func, const char* name, bool is_3d)
>> +                               texel_fetch_build_func txf_func, const char* name, bool is_3d,
>> +                               bool is_multisampled)
>>   {
>>          const struct glsl_type *vec4 = glsl_vec4_type();
>>          const struct glsl_type *vec2 = glsl_vector_type(GLSL_TYPE_FLOAT, 2);
>> @@ -538,11 +593,15 @@ build_nir_copy_fragment_shader(struct radv_device *device,
>>                                                        vec4, "f_color");
>>          color_out->data.location = FRAG_RESULT_DATA0;
>>
>> +       if (is_multisampled) {
>> +               build_nir_store_sample_mask(&b);
>> +       }
>> +
>>          nir_ssa_def *pos_int = nir_f2i32(&b, nir_load_var(&b, tex_pos_in));
>>          unsigned swiz[4] = { 0, 1 };
>>          nir_ssa_def *tex_pos = nir_swizzle(&b, pos_int, swiz, 2, false);
>>
>> -       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d);
>> +       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d, is_multisampled);
>>          nir_store_var(&b, color_out, color, 0xf);
>>
>>          return b.shader;
>> @@ -550,7 +609,8 @@ build_nir_copy_fragment_shader(struct radv_device *device,
>>
>>   static nir_shader *
>>   build_nir_copy_fragment_shader_depth(struct radv_device *device,
>> -                                    texel_fetch_build_func txf_func, const char* name, bool is_3d)
>> +                                    texel_fetch_build_func txf_func, const char* name, bool is_3d,
>> +                                    bool is_multisampled)
>>   {
>>          const struct glsl_type *vec4 = glsl_vec4_type();
>>          const struct glsl_type *vec2 = glsl_vector_type(GLSL_TYPE_FLOAT, 2);
>> @@ -567,11 +627,15 @@ build_nir_copy_fragment_shader_depth(struct radv_device *device,
>>                                                        vec4, "f_color");
>>          color_out->data.location = FRAG_RESULT_DEPTH;
>>
>> +       if (is_multisampled) {
>> +               build_nir_store_sample_mask(&b);
>> +       }
>> +
>>          nir_ssa_def *pos_int = nir_f2i32(&b, nir_load_var(&b, tex_pos_in));
>>          unsigned swiz[4] = { 0, 1 };
>>          nir_ssa_def *tex_pos = nir_swizzle(&b, pos_int, swiz, 2, false);
>>
>> -       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d);
>> +       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d, is_multisampled);
>>          nir_store_var(&b, color_out, color, 0x1);
>>
>>          return b.shader;
>> @@ -579,7 +643,8 @@ build_nir_copy_fragment_shader_depth(struct radv_device *device,
>>
>>   static nir_shader *
>>   build_nir_copy_fragment_shader_stencil(struct radv_device *device,
>> -                                      texel_fetch_build_func txf_func, const char* name, bool is_3d)
>> +                                      texel_fetch_build_func txf_func, const char* name, bool is_3d,
>> +                                      bool is_multisampled)
>>   {
>>          const struct glsl_type *vec4 = glsl_vec4_type();
>>          const struct glsl_type *vec2 = glsl_vector_type(GLSL_TYPE_FLOAT, 2);
>> @@ -596,11 +661,15 @@ build_nir_copy_fragment_shader_stencil(struct radv_device *device,
>>                                                        vec4, "f_color");
>>          color_out->data.location = FRAG_RESULT_STENCIL;
>>
>> +       if (is_multisampled) {
>> +               build_nir_store_sample_mask(&b);
>> +       }
>> +
>>          nir_ssa_def *pos_int = nir_f2i32(&b, nir_load_var(&b, tex_pos_in));
>>          unsigned swiz[4] = { 0, 1 };
>>          nir_ssa_def *tex_pos = nir_swizzle(&b, pos_int, swiz, 2, false);
>>
>> -       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d);
>> +       nir_ssa_def *color = txf_func(&b, device, tex_pos, is_3d, is_multisampled);
>>          nir_store_var(&b, color_out, color, 0x1);
>>
>>          return b.shader;
>> @@ -614,45 +683,48 @@ radv_device_finish_meta_blit2d_state(struct radv_device *device)
>>          for(unsigned j = 0; j < NUM_META_FS_KEYS; ++j) {
>>                  for (unsigned k = 0; k < RADV_META_DST_LAYOUT_COUNT; ++k) {
>>                          radv_DestroyRenderPass(radv_device_to_handle(device),
>> -                                              state->blit2d.render_passes[j][k],
>> -                                              &state->alloc);
>> +                                              state->blit2d_render_passes[j][k],
>> +                                              &state->alloc);
>>                  }
>>          }
>>
>>          for (enum radv_blit_ds_layout j = RADV_BLIT_DS_LAYOUT_TILE_ENABLE; j < RADV_BLIT_DS_LAYOUT_COUNT; j++) {
>>                  radv_DestroyRenderPass(radv_device_to_handle(device),
>> -                                      state->blit2d.depth_only_rp[j], &state->alloc);
>> +                                      state->blit2d_depth_only_rp[j], &state->alloc);
>>                  radv_DestroyRenderPass(radv_device_to_handle(device),
>> -                                      state->blit2d.stencil_only_rp[j], &state->alloc);
>> +                                      state->blit2d_stencil_only_rp[j], &state->alloc);
>>          }
>>
>> -       for (unsigned src = 0; src < BLIT2D_NUM_SRC_TYPES; src++) {
>> -               radv_DestroyPipelineLayout(radv_device_to_handle(device),
>> -                                          state->blit2d.p_layouts[src],
>> -                                          &state->alloc);
>> -               radv_DestroyDescriptorSetLayout(radv_device_to_handle(device),
>> -                                               state->blit2d.ds_layouts[src],
>> -                                               &state->alloc);
>> +       for (unsigned log2_samples = 0; log2_samples < 1 + MAX_SAMPLES_LOG2; ++log2_samples) {
>> +               for (unsigned src = 0; src < BLIT2D_NUM_SRC_TYPES; src++) {
>> +                       radv_DestroyPipelineLayout(radv_device_to_handle(device),
>> +                                                  state->blit2d[log2_samples].p_layouts[src],
>> +                                                  &state->alloc);
>> +                       radv_DestroyDescriptorSetLayout(radv_device_to_handle(device),
>> +                                                       state->blit2d[log2_samples].ds_layouts[src],
>> +                                                       &state->alloc);
>> +
>> +                       for (unsigned j = 0; j < NUM_META_FS_KEYS; ++j) {
>> +                               radv_DestroyPipeline(radv_device_to_handle(device),
>> +                                                    state->blit2d[log2_samples].pipelines[src][j],
>> +                                                    &state->alloc);
>> +                       }
>>
>> -               for (unsigned j = 0; j < NUM_META_FS_KEYS; ++j) {
>>                          radv_DestroyPipeline(radv_device_to_handle(device),
>> -                                            state->blit2d.pipelines[src][j],
>> +                                            state->blit2d[log2_samples].depth_only_pipeline[src],
>> +                                            &state->alloc);
>> +                       radv_DestroyPipeline(radv_device_to_handle(device),
>> +                                            state->blit2d[log2_samples].stencil_only_pipeline[src],
>>                                               &state->alloc);
>>                  }
>> -
>> -               radv_DestroyPipeline(radv_device_to_handle(device),
>> -                                    state->blit2d.depth_only_pipeline[src],
>> -                                    &state->alloc);
>> -               radv_DestroyPipeline(radv_device_to_handle(device),
>> -                                    state->blit2d.stencil_only_pipeline[src],
>> -                                    &state->alloc);
>>          }
>>   }
>>
>>   static VkResult
>>   blit2d_init_color_pipeline(struct radv_device *device,
>>                             enum blit2d_src_type src_type,
>> -                          VkFormat format)
>> +                          VkFormat format,
>> +                          uint32_t log2_samples)
>>   {
>>          VkResult result;
>>          unsigned fs_key = radv_format_meta_fs_key(format);
>> @@ -681,7 +753,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>          struct radv_shader_module fs = { .nir = NULL };
>>
>>
>> -       fs.nir = build_nir_copy_fragment_shader(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D);
>> +       fs.nir = build_nir_copy_fragment_shader(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D, log2_samples > 0);
>>          vi_create_info = &normal_vi_create_info;
>>
>>          struct radv_shader_module vs = {
>> @@ -705,7 +777,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>          };
>>
>>          for (unsigned dst_layout = 0; dst_layout < RADV_META_DST_LAYOUT_COUNT; ++dst_layout) {
>> -               if (!device->meta_state.blit2d.render_passes[fs_key][dst_layout]) {
>> +               if (!device->meta_state.blit2d_render_passes[fs_key][dst_layout]) {
>>                          VkImageLayout layout = radv_meta_dst_layout_to_layout(dst_layout);
>>
>>                          result = radv_CreateRenderPass(radv_device_to_handle(device),
>> @@ -737,7 +809,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>                                                  .pPreserveAttachments = (uint32_t[]) { 0 },
>>                                                  },
>>                                                  .dependencyCount = 0,
>> -                                       }, &device->meta_state.alloc, &device->meta_state.blit2d.render_passes[fs_key][dst_layout]);
>> +                                       }, &device->meta_state.alloc, &device->meta_state.blit2d_render_passes[fs_key][dst_layout]);
>>                  }
>>          }
>>
>> @@ -765,7 +837,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>                  },
>>                  .pMultisampleState = &(VkPipelineMultisampleStateCreateInfo) {
>>                          .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
>> -                       .rasterizationSamples = 1,
>> +                       .rasterizationSamples = 1 << log2_samples,
>>                          .sampleShadingEnable = false,
>>                          .pSampleMask = (VkSampleMask[]) { UINT32_MAX },
>>                  },
>> @@ -796,8 +868,8 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>                          },
>>                  },
>>                  .flags = 0,
>> -               .layout = device->meta_state.blit2d.p_layouts[src_type],
>> -               .renderPass = device->meta_state.blit2d.render_passes[fs_key][0],
>> +               .layout = device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>> +               .renderPass = device->meta_state.blit2d_render_passes[fs_key][0],
>>                  .subpass = 0,
>>          };
>>
>> @@ -809,7 +881,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>                                                 radv_pipeline_cache_to_handle(&device->meta_state.cache),
>>                                                 &vk_pipeline_info, &radv_pipeline_info,
>>                                                 &device->meta_state.alloc,
>> -                                              &device->meta_state.blit2d.pipelines[src_type][fs_key]);
>> +                                              &device->meta_state.blit2d[log2_samples].pipelines[src_type][fs_key]);
>>
>>
>>          ralloc_free(vs.nir);
>> @@ -820,7 +892,8 @@ blit2d_init_color_pipeline(struct radv_device *device,
>>
>>   static VkResult
>>   blit2d_init_depth_only_pipeline(struct radv_device *device,
>> -                               enum blit2d_src_type src_type)
>> +                               enum blit2d_src_type src_type,
>> +                               uint32_t log2_samples)
>>   {
>>          VkResult result;
>>          const char *name;
>> @@ -847,7 +920,7 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>          const VkPipelineVertexInputStateCreateInfo *vi_create_info;
>>          struct radv_shader_module fs = { .nir = NULL };
>>
>> -       fs.nir = build_nir_copy_fragment_shader_depth(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D);
>> +       fs.nir = build_nir_copy_fragment_shader_depth(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D, log2_samples > 0);
>>          vi_create_info = &normal_vi_create_info;
>>
>>          struct radv_shader_module vs = {
>> @@ -871,7 +944,7 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>          };
>>
>>          for (enum radv_blit_ds_layout ds_layout = RADV_BLIT_DS_LAYOUT_TILE_ENABLE; ds_layout < RADV_BLIT_DS_LAYOUT_COUNT; ds_layout++) {
>> -               if (!device->meta_state.blit2d.depth_only_rp[ds_layout]) {
>> +               if (!device->meta_state.blit2d_depth_only_rp[ds_layout]) {
>>                          VkImageLayout layout = radv_meta_blit_ds_to_layout(ds_layout);
>>                          result = radv_CreateRenderPass(radv_device_to_handle(device),
>>                                                         &(VkRenderPassCreateInfo) {
>> @@ -899,7 +972,7 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>                                                                         .pPreserveAttachments = (uint32_t[]) { 0 },
>>                                                                 },
>>                                                                 .dependencyCount = 0,
>> -                                                       }, &device->meta_state.alloc, &device->meta_state.blit2d.depth_only_rp[ds_layout]);
>> +                                                       }, &device->meta_state.alloc, &device->meta_state.blit2d_depth_only_rp[ds_layout]);
>>                  }
>>          }
>>
>> @@ -927,7 +1000,7 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>                  },
>>                  .pMultisampleState = &(VkPipelineMultisampleStateCreateInfo) {
>>                          .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
>> -                       .rasterizationSamples = 1,
>> +                       .rasterizationSamples = 1 << log2_samples,
>>                          .sampleShadingEnable = false,
>>                          .pSampleMask = (VkSampleMask[]) { UINT32_MAX },
>>                  },
>> @@ -958,8 +1031,8 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>                          },
>>                  },
>>                  .flags = 0,
>> -               .layout = device->meta_state.blit2d.p_layouts[src_type],
>> -               .renderPass = device->meta_state.blit2d.depth_only_rp[0],
>> +               .layout = device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>> +               .renderPass = device->meta_state.blit2d_depth_only_rp[0],
>>                  .subpass = 0,
>>          };
>>
>> @@ -971,7 +1044,7 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>                                                 radv_pipeline_cache_to_handle(&device->meta_state.cache),
>>                                                 &vk_pipeline_info, &radv_pipeline_info,
>>                                                 &device->meta_state.alloc,
>> -                                              &device->meta_state.blit2d.depth_only_pipeline[src_type]);
>> +                                              &device->meta_state.blit2d[log2_samples].depth_only_pipeline[src_type]);
>>
>>
>>          ralloc_free(vs.nir);
>> @@ -982,7 +1055,8 @@ blit2d_init_depth_only_pipeline(struct radv_device *device,
>>
>>   static VkResult
>>   blit2d_init_stencil_only_pipeline(struct radv_device *device,
>> -                                 enum blit2d_src_type src_type)
>> +                                 enum blit2d_src_type src_type,
>> +                                 uint32_t log2_samples)
>>   {
>>          VkResult result;
>>          const char *name;
>> @@ -1009,7 +1083,7 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>          const VkPipelineVertexInputStateCreateInfo *vi_create_info;
>>          struct radv_shader_module fs = { .nir = NULL };
>>
>> -       fs.nir = build_nir_copy_fragment_shader_stencil(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D);
>> +       fs.nir = build_nir_copy_fragment_shader_stencil(device, src_func, name, src_type == BLIT2D_SRC_TYPE_IMAGE_3D, log2_samples > 0);
>>          vi_create_info = &normal_vi_create_info;
>>
>>          struct radv_shader_module vs = {
>> @@ -1033,7 +1107,7 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>          };
>>
>>          for (enum radv_blit_ds_layout ds_layout = RADV_BLIT_DS_LAYOUT_TILE_ENABLE; ds_layout < RADV_BLIT_DS_LAYOUT_COUNT; ds_layout++) {
>> -               if (!device->meta_state.blit2d.stencil_only_rp[ds_layout]) {
>> +               if (!device->meta_state.blit2d_stencil_only_rp[ds_layout]) {
>>                          VkImageLayout layout = radv_meta_blit_ds_to_layout(ds_layout);
>>                          result = radv_CreateRenderPass(radv_device_to_handle(device),
>>                                                         &(VkRenderPassCreateInfo) {
>> @@ -1061,7 +1135,7 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>                                                                         .pPreserveAttachments = (uint32_t[]) { 0 },
>>                                                                 },
>>                                                                 .dependencyCount = 0,
>> -                                                      }, &device->meta_state.alloc, &device->meta_state.blit2d.stencil_only_rp[ds_layout]);
>> +                                                      }, &device->meta_state.alloc, &device->meta_state.blit2d_stencil_only_rp[ds_layout]);
>>                  }
>>          }
>>
>> @@ -1089,7 +1163,7 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>                  },
>>                  .pMultisampleState = &(VkPipelineMultisampleStateCreateInfo) {
>>                          .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
>> -                       .rasterizationSamples = 1,
>> +                       .rasterizationSamples = 1 << log2_samples,
>>                          .sampleShadingEnable = false,
>>                          .pSampleMask = (VkSampleMask[]) { UINT32_MAX },
>>                  },
>> @@ -1136,8 +1210,8 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>                          },
>>                  },
>>                  .flags = 0,
>> -               .layout = device->meta_state.blit2d.p_layouts[src_type],
>> -               .renderPass = device->meta_state.blit2d.stencil_only_rp[0],
>> +               .layout = device->meta_state.blit2d[log2_samples].p_layouts[src_type],
>> +               .renderPass = device->meta_state.blit2d_stencil_only_rp[0],
>>                  .subpass = 0,
>>          };
>>
>> @@ -1149,7 +1223,7 @@ blit2d_init_stencil_only_pipeline(struct radv_device *device,
>>                                                 radv_pipeline_cache_to_handle(&device->meta_state.cache),
>>                                                 &vk_pipeline_info, &radv_pipeline_info,
>>                                                 &device->meta_state.alloc,
>> -                                              &device->meta_state.blit2d.stencil_only_pipeline[src_type]);
>> +                                              &device->meta_state.blit2d[log2_samples].stencil_only_pipeline[src_type]);
>>
>>
>>          ralloc_free(vs.nir);
>> @@ -1175,15 +1249,16 @@ static VkFormat pipeline_formats[] = {
>>
>>   static VkResult
>>   meta_blit2d_create_pipe_layout(struct radv_device *device,
>> -                              int idx)
>> +                              int idx,
>> +                              uint32_t log2_samples)
>>   {
>>          VkResult result;
>>          VkDescriptorType desc_type = (idx == BLIT2D_SRC_TYPE_BUFFER) ? VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
>>          const VkPushConstantRange push_constant_ranges[] = {
>>                  {VK_SHADER_STAGE_VERTEX_BIT, 0, 16},
>> -               {VK_SHADER_STAGE_FRAGMENT_BIT, 16, 4},
>> +               {VK_SHADER_STAGE_FRAGMENT_BIT, 16, 12},
>>          };
>> -       int num_push_constant_range = (idx != BLIT2D_SRC_TYPE_IMAGE) ? 2 : 1;
>> +       int num_push_constant_range = (idx != BLIT2D_SRC_TYPE_IMAGE || log2_samples > 0) ? 2 : 1;
>>
>>          result = radv_CreateDescriptorSetLayout(radv_device_to_handle(device),
>>                                                  &(VkDescriptorSetLayoutCreateInfo) {
>> @@ -1199,7 +1274,7 @@ meta_blit2d_create_pipe_layout(struct radv_device *device,
>>                                                                  .pImmutableSamplers = NULL
>>                                                          },
>>                                                          }
>> -                                               }, &device->meta_state.alloc, &device->meta_state.blit2d.ds_layouts[idx]);
>> +                                               }, &device->meta_state.alloc, &device->meta_state.blit2d[log2_samples].ds_layouts[idx]);
>>          if (result != VK_SUCCESS)
>>                  goto fail;
>>
>> @@ -1207,11 +1282,11 @@ meta_blit2d_create_pipe_layout(struct radv_device *device,
>>                                             &(VkPipelineLayoutCreateInfo) {
>>                                                     .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
>>                                                             .setLayoutCount = 1,
>> -                                                          .pSetLayouts = &device->meta_state.blit2d.ds_layouts[idx],
>> +                                                          .pSetLayouts = &device->meta_state.blit2d[log2_samples].ds_layouts[idx],
>>                                                             .pushConstantRangeCount = num_push_constant_range,
>>                                                             .pPushConstantRanges = push_constant_ranges,
>>                                                             },
>> -                                          &device->meta_state.alloc, &device->meta_state.blit2d.p_layouts[idx]);
>> +                                          &device->meta_state.alloc, &device->meta_state.blit2d[log2_samples].p_layouts[idx]);
>>          if (result != VK_SUCCESS)
>>                  goto fail;
>>          return VK_SUCCESS;
>> @@ -1225,27 +1300,33 @@ radv_device_init_meta_blit2d_state(struct radv_device *device)
>>          VkResult result;
>>          bool create_3d = device->physical_device->rad_info.chip_class >= GFX9;
>>
>> -       for (unsigned src = 0; src < BLIT2D_NUM_SRC_TYPES; src++) {
>> -               if (src == BLIT2D_SRC_TYPE_IMAGE_3D && !create_3d)
>> -                       continue;
>> +       for (unsigned log2_samples = 0; log2_samples < 1 + MAX_SAMPLES_LOG2; log2_samples++) {
>> +               for (unsigned src = 0; src < BLIT2D_NUM_SRC_TYPES; src++) {
>> +                       if (src == BLIT2D_SRC_TYPE_IMAGE_3D && !create_3d)
>> +                               continue;
>>
>> -               result = meta_blit2d_create_pipe_layout(device, src);
>> -               if (result != VK_SUCCESS)
>> -                       goto fail;
>> +                       /* Don't need to handle copies between buffers and multisample images. */
>> +                       if (src == BLIT2D_SRC_TYPE_BUFFER && log2_samples > 0)
>> +                               continue;
>>
>> -               for (unsigned j = 0; j < ARRAY_SIZE(pipeline_formats); ++j) {
>> -                       result = blit2d_init_color_pipeline(device, src, pipeline_formats[j]);
>> +                       result = meta_blit2d_create_pipe_layout(device, src, log2_samples);
>>                          if (result != VK_SUCCESS)
>>                                  goto fail;
>> -               }
>>
>> -               result = blit2d_init_depth_only_pipeline(device, src);
>> -               if (result != VK_SUCCESS)
>> -                       goto fail;
>> +                       for (unsigned j = 0; j < ARRAY_SIZE(pipeline_formats); ++j) {
>> +                               result = blit2d_init_color_pipeline(device, src, pipeline_formats[j], log2_samples);
>> +                               if (result != VK_SUCCESS)
>> +                                       goto fail;
>> +                       }
>> +
>> +                       result = blit2d_init_depth_only_pipeline(device, src, log2_samples);
>> +                       if (result != VK_SUCCESS)
>> +                               goto fail;
>>
>> -               result = blit2d_init_stencil_only_pipeline(device, src);
>> -               if (result != VK_SUCCESS)
>> -                       goto fail;
>> +                       result = blit2d_init_stencil_only_pipeline(device, src, log2_samples);
>> +                       if (result != VK_SUCCESS)
>> +                               goto fail;
>> +               }
>>          }
>>
>>          return VK_SUCCESS;
>> diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h
>> index 1869604e9e..3c548fe059 100644
>> --- a/src/amd/vulkan/radv_private.h
>> +++ b/src/amd/vulkan/radv_private.h
>> @@ -462,18 +462,18 @@ struct radv_meta_state {
>>          } blit;
>>
>>          struct {
>> -               VkRenderPass render_passes[NUM_META_FS_KEYS][RADV_META_DST_LAYOUT_COUNT];
>> +               VkPipelineLayout p_layouts[5];
>> +               VkDescriptorSetLayout ds_layouts[5];
>> +               VkPipeline pipelines[5][NUM_META_FS_KEYS];
>>
>> -               VkPipelineLayout p_layouts[3];
>> -               VkDescriptorSetLayout ds_layouts[3];
>> -               VkPipeline pipelines[3][NUM_META_FS_KEYS];
>> +               VkPipeline depth_only_pipeline[5];
>>
>> -               VkRenderPass depth_only_rp[RADV_BLIT_DS_LAYOUT_COUNT];
>> -               VkPipeline depth_only_pipeline[3];
>> +               VkPipeline stencil_only_pipeline[5];
>> +       } blit2d[1 + MAX_SAMPLES_LOG2];
>>
>> -               VkRenderPass stencil_only_rp[RADV_BLIT_DS_LAYOUT_COUNT];
>> -               VkPipeline stencil_only_pipeline[3];
>> -       } blit2d;
>> +       VkRenderPass blit2d_render_passes[NUM_META_FS_KEYS][RADV_META_DST_LAYOUT_COUNT];
>> +       VkRenderPass blit2d_depth_only_rp[RADV_BLIT_DS_LAYOUT_COUNT];
>> +       VkRenderPass blit2d_stencil_only_rp[RADV_BLIT_DS_LAYOUT_COUNT];
>>
>>          struct {
>>                  VkPipelineLayout                          img_p_layout;
>> --
>> 2.14.3
>>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
> 


More information about the mesa-dev mailing list