fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 15:58:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

radv/meta: Stop using strings for meta keys

Browse source 
Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/33405>
This commit is contained in:
Konstantin Seurer 2025-01-04 19:38:57 +01:00 • committed by Marge Bot
parent 1d051e5cb1
commit 662bcc8717
16 changed files with 425 additions and 194 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/amd/vulkan/meta/radv_meta.c
View file

@ -612,8 +612,8 @@ radv_break_on_count(nir_builder *b, nir_variable *var, nir_def *count)
VkResult
radv_meta_get_noop_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-noop";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_NOOP;
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, NULL, key_data, strlen(key_data),
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, NULL, &key, sizeof(key),
layout_out);
}

38
src/amd/vulkan/meta/radv_meta.h
View file

@ -102,6 +102,44 @@ radv_meta_dst_layout_to_layout(enum radv_meta_dst_layout layout)
extern const VkFormat radv_fs_key_format_exemplars[NUM_META_FS_KEYS];
enum radv_meta_object_key_type {
RADV_META_OBJECT_KEY_NOOP = VK_META_OBJECT_KEY_DRIVER_OFFSET,
RADV_META_OBJECT_KEY_BLIT,
RADV_META_OBJECT_KEY_BLIT2D,
RADV_META_OBJECT_KEY_BLIT2D_COLOR,
RADV_META_OBJECT_KEY_BLIT2D_DEPTH,
RADV_META_OBJECT_KEY_BLIT2D_STENCIL,
RADV_META_OBJECT_KEY_FILL_BUFFER,
RADV_META_OBJECT_KEY_COPY_BUFFER,
RADV_META_OBJECT_KEY_COPY_IMAGE_TO_BUFFER,
RADV_META_OBJECT_KEY_COPY_BUFFER_TO_IMAGE,
RADV_META_OBJECT_KEY_COPY_BUFFER_TO_IMAGE_R32G32B32,
RADV_META_OBJECT_KEY_COPY_IMAGE,
RADV_META_OBJECT_KEY_COPY_IMAGE_R32G32B32,
RADV_META_OBJECT_KEY_COPY_VRS_HTILE,
RADV_META_OBJECT_KEY_CLEAR_CS,
RADV_META_OBJECT_KEY_CLEAR_CS_R32G32B32,
RADV_META_OBJECT_KEY_CLEAR_COLOR,
RADV_META_OBJECT_KEY_CLEAR_DS,
RADV_META_OBJECT_KEY_CLEAR_HTILE,
RADV_META_OBJECT_KEY_CLEAR_DCC_COMP_TO_SINGLE,
RADV_META_OBJECT_KEY_FAST_CLEAR_ELIMINATE,
RADV_META_OBJECT_KEY_DCC_DECOMPRESS,
RADV_META_OBJECT_KEY_DCC_RETILE,
RADV_META_OBJECT_KEY_HTILE_EXPAND_GFX,
RADV_META_OBJECT_KEY_HTILE_EXPAND_CS,
RADV_META_OBJECT_KEY_FMASK_COPY,
RADV_META_OBJECT_KEY_FMASK_EXPAND,
RADV_META_OBJECT_KEY_FMASK_DECOMPRESS,
RADV_META_OBJECT_KEY_RESOLVE_HW,
RADV_META_OBJECT_KEY_RESOLVE_CS,
RADV_META_OBJECT_KEY_RESOLVE_COLOR_CS,
RADV_META_OBJECT_KEY_RESOLVE_DS_CS,
RADV_META_OBJECT_KEY_RESOLVE_FS,
RADV_META_OBJECT_KEY_RESOLVE_COLOR_FS,
RADV_META_OBJECT_KEY_RESOLVE_DS_FS,
};
VkResult radv_device_init_meta(struct radv_device *device);
void radv_device_finish_meta(struct radv_device *device);

29
src/amd/vulkan/meta/radv_meta_blit.c
View file

@ -165,7 +165,7 @@ translate_sampler_dim(VkImageType type)
static VkResult
get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-blit";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_BLIT;
const VkDescriptorSetLayoutBinding binding = {
.binding = 0,
@ -183,10 +183,17 @@ get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
const VkPushConstantRange pc_range = {VK_SHADER_STAGE_VERTEX_BIT, 0, 20};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_blit_key {
enum radv_meta_object_key_type type;
VkImageAspectFlags aspects;
VkImageType image_type;
uint32_t fs_key;
};
static VkResult
get_pipeline(struct radv_device *device, const struct radv_image_view *src_iview,
const struct radv_image_view *dst_iview, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
@ -195,18 +202,20 @@ get_pipeline(struct radv_device *device, const struct radv_image_view *src_iview
const struct radv_image *src_image = src_iview->image;
const struct radv_image *dst_image = dst_iview->image;
const enum glsl_sampler_dim tex_dim = translate_sampler_dim(src_image->vk.image_type);
unsigned fs_key = 0;
char key_data[64];
struct radv_blit_key key;
VkResult result;
result = get_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
if (src_image->vk.aspects == VK_IMAGE_ASPECT_COLOR_BIT)
fs_key = radv_format_meta_fs_key(device, dst_image->vk.format);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_BLIT;
key.aspects = src_image->vk.aspects;
key.image_type = src_image->vk.image_type;
snprintf(key_data, sizeof(key_data), "radv-blit-%d-%d-%d", src_image->vk.aspects, src_image->vk.image_type, fs_key);
if (src_image->vk.aspects == VK_IMAGE_ASPECT_COLOR_BIT)
key.fs_key = radv_format_meta_fs_key(device, dst_image->vk.format);
nir_shader *fs;
nir_shader *vs = build_nir_vertex_shader(device);
@ -331,7 +340,7 @@ get_pipeline(struct radv_device *device, const struct radv_image_view *src_iview
case VK_IMAGE_ASPECT_COLOR_BIT:
pipeline_create_info.pColorBlendState = &color_blend_info;
render.color_attachment_count = 1;
render.color_attachment_formats[0] = radv_fs_key_format_exemplars[fs_key];
render.color_attachment_formats[0] = radv_fs_key_format_exemplars[key.fs_key];
break;
case VK_IMAGE_ASPECT_DEPTH_BIT:
pipeline_create_info.pDepthStencilState = &depth_info;
@ -346,7 +355,7 @@ get_pipeline(struct radv_device *device, const struct radv_image_view *src_iview
}
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs);
ralloc_free(fs);

58
src/amd/vulkan/meta/radv_meta_blit2d.c
View file

@ -446,14 +446,22 @@ build_nir_copy_fragment_shader_stencil(struct radv_device *device, texel_fetch_b
return b.shader;
}
struct radv_blit2d_key {
enum radv_meta_object_key_type type;
uint32_t index;
};
static VkResult
create_layout(struct radv_device *device, int idx, VkPipelineLayout *layout_out)
{
const VkDescriptorType desc_type =
(idx == BLIT2D_SRC_TYPE_BUFFER) ? VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
char key_data[64];
snprintf(key_data, sizeof(key_data), "radv-blit2d-%d", idx);
struct radv_blit2d_key key;
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_BLIT2D;
key.index = idx;
const VkDescriptorSetLayoutBinding binding = {
.binding = 0,
@ -474,16 +482,22 @@ create_layout(struct radv_device *device, int idx, VkPipelineLayout *layout_out)
.size = 20,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_blit2d_color_key {
enum radv_meta_object_key_type type;
enum blit2d_src_type src_type;
uint32_t log2_samples;
uint32_t fs_key;
};
static VkResult
get_color_pipeline(struct radv_device *device, enum blit2d_src_type src_type, VkFormat format, uint32_t log2_samples,
VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const unsigned fs_key = radv_format_meta_fs_key(device, format);
char key_data[64];
struct radv_blit2d_color_key key;
const char *name;
VkResult result;
@ -491,7 +505,11 @@ get_color_pipeline(struct radv_device *device, enum blit2d_src_type src_type, Vk
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-blit2d-color-%d-%d-%d", src_type, log2_samples, fs_key);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_BLIT2D_COLOR;
key.src_type = src_type;
key.log2_samples = log2_samples;
key.fs_key = radv_format_meta_fs_key(device, format);
texel_fetch_build_func src_func;
switch (src_type) {
@ -597,18 +615,24 @@ get_color_pipeline(struct radv_device *device, enum blit2d_src_type src_type, Vk
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
return result;
}
struct radv_blit2d_ds_key {
enum radv_meta_object_key_type type;
enum blit2d_src_type src_type;
uint32_t log2_samples;
};
static VkResult
get_depth_only_pipeline(struct radv_device *device, enum blit2d_src_type src_type, uint32_t log2_samples,
VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
char key_data[64];
struct radv_blit2d_ds_key key;
const char *name;
VkResult result;
@ -616,7 +640,10 @@ get_depth_only_pipeline(struct radv_device *device, enum blit2d_src_type src_typ
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-blit2d-depth-%d-%d", src_type, log2_samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_BLIT2D_DEPTH;
key.src_type = src_type;
key.log2_samples = log2_samples;
texel_fetch_build_func src_func;
switch (src_type) {
@ -746,7 +773,7 @@ get_depth_only_pipeline(struct radv_device *device, enum blit2d_src_type src_typ
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
@ -757,7 +784,7 @@ static VkResult
get_stencil_only_pipeline(struct radv_device *device, enum blit2d_src_type src_type, uint32_t log2_samples,
VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
char key_data[64];
struct radv_blit2d_ds_key key;
const char *name;
VkResult result;
@ -765,7 +792,10 @@ get_stencil_only_pipeline(struct radv_device *device, enum blit2d_src_type src_t
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-blit2d-stencil-%d-%d", src_type, log2_samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_BLIT2D_STENCIL;
key.src_type = src_type;
key.log2_samples = log2_samples;
texel_fetch_build_func src_func;
switch (src_type) {
@ -890,7 +920,7 @@ get_stencil_only_pipeline(struct radv_device *device, enum blit2d_src_type src_t
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);

24
src/amd/vulkan/meta/radv_meta_buffer.c
View file

@ -39,7 +39,7 @@ struct fill_constants {
static VkResult
get_fill_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-fill-buffer";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_FILL_BUFFER;
VkResult result;
const VkPushConstantRange pc_range = {
@ -47,12 +47,12 @@ get_fill_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipeli
.size = sizeof(struct fill_constants),
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, &key, sizeof(key),
layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -75,8 +75,8 @@ get_fill_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipeli
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -114,7 +114,7 @@ struct copy_constants {
static VkResult
get_copy_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-copy-buffer";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_BUFFER;
VkResult result;
const VkPushConstantRange pc_range = {
@ -122,12 +122,12 @@ get_copy_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipeli
.size = sizeof(struct copy_constants),
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, &key, sizeof(key),
layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -150,8 +150,8 @@ get_copy_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipeli
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

129
src/amd/vulkan/meta/radv_meta_bufimage.c
View file

@ -58,7 +58,7 @@ build_nir_itob_compute_shader(struct radv_device *dev, bool is_3d)
static VkResult
get_itob_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-itob";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_IMAGE_TO_BUFFER;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -87,25 +87,32 @@ get_itob_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_ou
.size = 16,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_copy_buffer_image_key {
enum radv_meta_object_key_type type;
bool is_3d;
};
static VkResult
get_itob_pipeline(struct radv_device *device, const struct radv_image *image, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
{
const bool is_3d = image->vk.image_type == VK_IMAGE_TYPE_3D;
char key_data[64];
struct radv_copy_buffer_image_key key;
VkResult result;
result = get_itob_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-itob-%d", is_3d);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_COPY_IMAGE_TO_BUFFER;
key.is_3d = is_3d;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -128,8 +135,8 @@ get_itob_pipeline(struct radv_device *device, const struct radv_image *image, Vk
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -178,7 +185,7 @@ build_nir_btoi_compute_shader(struct radv_device *dev, bool is_3d)
static VkResult
get_btoi_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-btoi";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_BUFFER_TO_IMAGE;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -207,8 +214,8 @@ get_btoi_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_ou
.size = 16,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
static VkResult
@ -216,16 +223,18 @@ get_btoi_pipeline(struct radv_device *device, const struct radv_image *image, Vk
VkPipelineLayout *layout_out)
{
const bool is_3d = image->vk.image_type == VK_IMAGE_TYPE_3D;
char key_data[64];
struct radv_copy_buffer_image_key key;
VkResult result;
result = get_btoi_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-btoi-%d", is_3d);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_COPY_BUFFER_TO_IMAGE;
key.is_3d = is_3d;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -248,8 +257,8 @@ get_btoi_pipeline(struct radv_device *device, const struct radv_image *image, Vk
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -306,7 +315,7 @@ build_nir_btoi_r32g32b32_compute_shader(struct radv_device *dev)
static VkResult
get_btoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-btoi-r32g32b32";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_BUFFER_TO_IMAGE_R32G32B32;
VkResult result;
const VkDescriptorSetLayoutBinding bindings[] = {
@ -336,12 +345,12 @@ get_btoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out
.size = 16,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key,
sizeof(key), layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -364,8 +373,8 @@ get_btoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -428,7 +437,7 @@ build_nir_itoi_compute_shader(struct radv_device *dev, bool src_3d, bool dst_3d,
static VkResult
get_itoi_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-itoi";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_IMAGE;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -457,10 +466,17 @@ get_itoi_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_ou
.size = 24,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_copy_image_key {
enum radv_meta_object_key_type type;
bool src_3d;
bool dst_3d;
uint8_t samples_log2;
};
static VkResult
get_itoi_pipeline(struct radv_device *device, const struct radv_image *src_image, const struct radv_image *dst_image,
int samples, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
@ -469,15 +485,19 @@ get_itoi_pipeline(struct radv_device *device, const struct radv_image *src_image
const bool dst_3d = dst_image->vk.image_type == VK_IMAGE_TYPE_3D;
const uint32_t samples_log2 = ffs(samples) - 1;
VkResult result;
char key_data[64];
struct radv_copy_image_key key;
result = get_itoi_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-itoi-%d-%d-%d", src_3d, dst_3d, samples_log2);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_COPY_IMAGE;
key.src_3d = src_3d;
key.dst_3d = dst_3d;
key.samples_log2 = samples_log2;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -500,8 +520,8 @@ get_itoi_pipeline(struct radv_device *device, const struct radv_image *src_image
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -560,7 +580,7 @@ build_nir_itoi_r32g32b32_compute_shader(struct radv_device *dev)
static VkResult
get_itoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-itoi-r32g32b32";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_IMAGE_R32G32B32;
VkResult result;
const VkDescriptorSetLayoutBinding bindings[] = {
@ -590,12 +610,12 @@ get_itoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out
.size = 24,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key,
sizeof(key), layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -618,8 +638,8 @@ get_itoi_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -665,7 +685,7 @@ build_nir_cleari_compute_shader(struct radv_device *dev, bool is_3d, int samples
static VkResult
get_cleari_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-cleari";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_CLEAR_CS;
const VkDescriptorSetLayoutBinding binding = {
.binding = 0,
@ -686,10 +706,16 @@ get_cleari_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_
.size = 20,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_clear_key {
enum radv_meta_object_key_type type;
bool is_3d;
uint8_t samples_log2;
};
static VkResult
get_cleari_pipeline(struct radv_device *device, const struct radv_image *image, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
@ -697,16 +723,19 @@ get_cleari_pipeline(struct radv_device *device, const struct radv_image *image,
const bool is_3d = image->vk.image_type == VK_IMAGE_TYPE_3D;
const uint32_t samples = image->vk.samples;
const uint32_t samples_log2 = ffs(samples) - 1;
char key_data[64];
struct radv_clear_key key;
VkResult result;
result = get_cleari_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-cleari-%d-%d", is_3d, samples_log2);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_CLEAR_CS;
key.is_3d = is_3d;
key.samples_log2 = samples_log2;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -729,8 +758,8 @@ get_cleari_pipeline(struct radv_device *device, const struct radv_image *image,
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -774,7 +803,7 @@ build_nir_cleari_r32g32b32_compute_shader(struct radv_device *dev)
static VkResult
get_cleari_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-cleari-r32g32b32";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_CLEAR_CS_R32G32B32;
VkResult result;
const VkDescriptorSetLayoutBinding binding = {
@ -796,12 +825,12 @@ get_cleari_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_o
.size = 16,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key,
sizeof(key), layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -824,8 +853,8 @@ get_cleari_r32g32b32_pipeline(struct radv_device *device, VkPipeline *pipeline_o
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

96
src/amd/vulkan/meta/radv_meta_clear.c
View file

@ -57,32 +57,43 @@ build_color_shaders(struct radv_device *dev, struct nir_shader **out_vs, struct
static VkResult
get_color_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-clear-color";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_CLEAR_COLOR;
const VkPushConstantRange pc_range = {
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
.size = 16,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_clear_color_key {
enum radv_meta_object_key_type type;
uint8_t samples;
uint8_t frag_output;
uint32_t fs_key;
};
static VkResult
get_color_pipeline(struct radv_device *device, uint32_t samples, uint32_t frag_output, VkFormat format,
VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const uint32_t fs_key = radv_format_meta_fs_key(device, format);
char key_data[64];
struct radv_clear_color_key key;
VkResult result;
result = get_color_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-clear-color-%d-%d-%d", samples, frag_output, fs_key);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_CLEAR_COLOR;
key.samples = samples;
key.frag_output = frag_output;
key.fs_key = fs_key;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -198,7 +209,7 @@ get_color_pipeline(struct radv_device *device, uint32_t samples, uint32_t frag_o
render.color_attachment_formats[i] = format;
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
@ -317,37 +328,57 @@ static bool radv_can_fast_clear_depth(struct radv_cmd_buffer *cmd_buffer, const
const VkClearRect *clear_rect, const VkClearDepthStencilValue clear_value,
uint32_t view_mask);
struct radv_clear_ds_layout_key {
enum radv_meta_object_key_type type;
bool unrestricted;
};
static VkResult
get_depth_stencil_pipeline_layout(struct radv_device *device, bool unrestricted, VkPipelineLayout *layout_out)
{
char key_data[64];
struct radv_clear_ds_layout_key key;
snprintf(key_data, sizeof(key_data), "radv-clear-ds-%d", unrestricted);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_CLEAR_DS;
key.unrestricted = unrestricted;
const VkPushConstantRange pc_range = {
.stageFlags = unrestricted ? VK_SHADER_STAGE_FRAGMENT_BIT : VK_SHADER_STAGE_VERTEX_BIT,
.size = 4,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, NULL, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_clear_ds_key {
enum radv_meta_object_key_type type;
VkImageAspectFlags aspects;
uint8_t samples;
bool fast;
bool unrestricted;
};
static VkResult
get_depth_stencil_pipeline(struct radv_device *device, int samples, VkImageAspectFlags aspects, bool fast,
VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const bool unrestricted = device->vk.enabled_extensions.EXT_depth_range_unrestricted;
char key_data[64];
struct radv_clear_ds_key key;
VkResult result;
result = get_depth_stencil_pipeline_layout(device, unrestricted, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-clear-ds-%d-%d-%d-%d", aspects, samples, fast, unrestricted);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_CLEAR_DS;
key.aspects = aspects;
key.samples = samples;
key.fast = fast;
key.unrestricted = unrestricted;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -475,7 +506,7 @@ get_depth_stencil_pipeline(struct radv_device *device, int samples, VkImageAspec
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
@ -584,7 +615,7 @@ build_clear_htile_mask_shader(struct radv_device *dev)
static VkResult
get_clear_htile_mask_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-clear-htile-mask";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_CLEAR_HTILE;
VkResult result;
const VkDescriptorSetLayoutBinding binding = {
@ -606,12 +637,12 @@ get_clear_htile_mask_pipeline(struct radv_device *device, VkPipeline *pipeline_o
.size = 8,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key,
sizeof(key), layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -634,8 +665,8 @@ get_clear_htile_mask_pipeline(struct radv_device *device, VkPipeline *pipeline_o
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -1033,7 +1064,7 @@ radv_clear_dcc(struct radv_cmd_buffer *cmd_buffer, struct radv_image *image, con
static VkResult
get_clear_dcc_comp_to_single_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-clear-dcc-comp-to-single";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_CLEAR_DCC_COMP_TO_SINGLE;
const VkDescriptorSetLayoutBinding binding = {
.binding = 0,
@ -1054,24 +1085,31 @@ get_clear_dcc_comp_to_single_pipeline_layout(struct radv_device *device, VkPipel
.size = 24,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_clear_dcc_comp_to_single_key {
enum radv_meta_object_key_type type;
bool is_msaa;
};
static VkResult
get_clear_dcc_comp_to_single_pipeline(struct radv_device *device, bool is_msaa, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
{
char key_data[64];
struct radv_clear_dcc_comp_to_single_key key;
VkResult result;
result = get_clear_dcc_comp_to_single_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-clear-dcc-comp-to-single-%d", is_msaa);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_CLEAR_DCC_COMP_TO_SINGLE;
key.is_msaa = is_msaa;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -1094,8 +1132,8 @@ get_clear_dcc_comp_to_single_pipeline(struct radv_device *device, bool is_msaa,
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

12
src/amd/vulkan/meta/radv_meta_copy_vrs_htile.c
View file

@ -96,7 +96,7 @@ static VkResult
get_pipeline(struct radv_device *device, struct radv_image *image, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
{
const char *key_data = "radv-copy-vrs-htile";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_COPY_VRS_HTILE;
VkResult result;
const VkDescriptorSetLayoutBinding bindings[] = {
@ -126,12 +126,12 @@ get_pipeline(struct radv_device *device, struct radv_image *image, VkPipeline *p
.size = 20,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key,
sizeof(key), layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -154,8 +154,8 @@ get_pipeline(struct radv_device *device, struct radv_image *image, VkPipeline *p
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

23
src/amd/vulkan/meta/radv_meta_dcc_retile.c
View file

@ -62,7 +62,7 @@ build_dcc_retile_compute_shader(struct radv_device *dev, struct radeon_surf *sur
static VkResult
get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-dcc-retile";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_DCC_RETILE;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -92,10 +92,15 @@ get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
.size = 16,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_dcc_retile_key {
enum radv_meta_object_key_type type;
uint32_t swizzle;
};
/*
* This take a surface, but the only things used are:
* - BPE
@ -109,16 +114,18 @@ get_pipeline(struct radv_device *device, struct radv_image *image, VkPipeline *p
VkPipelineLayout *layout_out)
{
const unsigned swizzle_mode = image->planes[0].surface.u.gfx9.swizzle_mode;
char key_data[64];
struct radv_dcc_retile_key key;
VkResult result;
result = get_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-dcc-retile-%d", swizzle_mode);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_DCC_RETILE;
key.swizzle = swizzle_mode;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -141,8 +148,8 @@ get_pipeline(struct radv_device *device, struct radv_image *image, VkPipeline *p
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

27
src/amd/vulkan/meta/radv_meta_decompress.c
View file

@ -50,20 +50,27 @@ build_expand_depth_stencil_compute_shader(struct radv_device *dev)
return b.shader;
}
struct radv_htile_expand_key {
enum radv_meta_object_key_type type;
uint32_t samples;
};
static VkResult
get_pipeline_gfx(struct radv_device *device, struct radv_image *image, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const uint32_t samples = image->vk.samples;
char key_data[64];
struct radv_htile_expand_key key;
VkResult result;
result = radv_meta_get_noop_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-htile-expand-gfx-%d", samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_HTILE_EXPAND_GFX;
key.samples = samples;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -174,7 +181,7 @@ get_pipeline_gfx(struct radv_device *device, struct radv_image *image, VkPipelin
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
@ -311,7 +318,7 @@ radv_process_depth_stencil(struct radv_cmd_buffer *cmd_buffer, struct radv_image
static VkResult
get_pipeline_cs(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-htile-expand-cs";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_HTILE_EXPAND_CS;
VkResult result;
const VkDescriptorSetLayoutBinding bindings[] = {
@ -337,12 +344,12 @@ get_pipeline_cs(struct radv_device *device, VkPipeline *pipeline_out, VkPipeline
.pBindings = bindings,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, &key, sizeof(key),
layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -365,8 +372,8 @@ get_pipeline_cs(struct radv_device *device, VkPipeline *pipeline_out, VkPipeline
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

30
src/amd/vulkan/meta/radv_meta_fast_clear.c
View file

@ -56,7 +56,7 @@ build_dcc_decompress_compute_shader(struct radv_device *dev)
static VkResult
get_dcc_decompress_compute_pipeline(struct radv_device *device, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-dcc-decompress-cs";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_DCC_DECOMPRESS;
VkResult result;
const VkDescriptorSetLayoutBinding bindings[] = {
@ -81,12 +81,12 @@ get_dcc_decompress_compute_pipeline(struct radv_device *device, VkPipeline *pipe
.pBindings = bindings,
};
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, key_data,
strlen(key_data), layout_out);
result = vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, &key, sizeof(key),
layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -109,8 +109,8 @@ get_dcc_decompress_compute_pipeline(struct radv_device *device, VkPipeline *pipe
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -120,16 +120,26 @@ static VkResult
get_pipeline(struct radv_device *device, enum radv_color_op op, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const struct radv_physical_device *pdev = radv_device_physical(device);
char key_data[64];
enum radv_meta_object_key_type key = 0;
VkResult result;
snprintf(key_data, sizeof(key_data), "radv-color-op-%d", op);
switch (op) {
case FAST_CLEAR_ELIMINATE:
key = RADV_META_OBJECT_KEY_FAST_CLEAR_ELIMINATE;
break;
case FMASK_DECOMPRESS:
key = RADV_META_OBJECT_KEY_FMASK_DECOMPRESS;
break;
case DCC_DECOMPRESS:
key = RADV_META_OBJECT_KEY_DCC_DECOMPRESS;
break;
}
result = radv_meta_get_noop_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -244,7 +254,7 @@ get_pipeline(struct radv_device *device, enum radv_color_op op, VkPipeline *pipe
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);

23
src/amd/vulkan/meta/radv_meta_fmask_copy.c
View file

@ -85,7 +85,7 @@ build_fmask_copy_compute_shader(struct radv_device *dev, int samples)
static VkResult
get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-fmask-copy";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_FMASK_COPY;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -109,24 +109,31 @@ get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
.pBindings = bindings,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, &key, sizeof(key),
layout_out);
}
struct radv_fmask_copy_key {
enum radv_meta_object_key_type type;
uint32_t samples;
};
static VkResult
get_pipeline(struct radv_device *device, uint32_t samples_log2, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const uint32_t samples = 1 << samples_log2;
char key_data[64];
struct radv_fmask_copy_key key;
VkResult result;
result = get_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-fmask-copy-%d", samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_FMASK_COPY;
key.samples = samples;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -149,8 +156,8 @@ get_pipeline(struct radv_device *device, uint32_t samples_log2, VkPipeline *pipe
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

23
src/amd/vulkan/meta/radv_meta_fmask_expand.c
View file

@ -52,7 +52,7 @@ build_fmask_expand_compute_shader(struct radv_device *device, int samples)
static VkResult
get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-fmask-expand";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_FMASK_EXPAND;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -76,24 +76,31 @@ get_pipeline_layout(struct radv_device *device, VkPipelineLayout *layout_out)
.pBindings = bindings,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, NULL, &key, sizeof(key),
layout_out);
}
struct radv_fmask_expand_key {
enum radv_meta_object_key_type type;
uint32_t samples;
};
static VkResult
get_pipeline(struct radv_device *device, uint32_t samples_log2, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const uint32_t samples = 1 << samples_log2;
char key_data[64];
struct radv_fmask_expand_key key;
VkResult result;
result = get_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-fmask-expand-%d", samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_FMASK_EXPAND;
key.samples = samples;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -116,8 +123,8 @@ get_pipeline(struct radv_device *device, uint32_t samples_log2, VkPipeline *pipe
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

13
src/amd/vulkan/meta/radv_meta_resolve.c
View file

@ -28,14 +28,21 @@ build_nir_fs(struct radv_device *dev)
return b.shader;
}
struct radv_resolve_key {
enum radv_meta_object_key_type type;
uint32_t fs_key;
};
static VkResult
get_pipeline(struct radv_device *device, unsigned fs_key, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
{
const VkFormat format = radv_fs_key_format_exemplars[fs_key];
char key_data[64];
struct radv_resolve_key key;
VkResult result;
snprintf(key_data, sizeof(key_data), "radv-resolve-hw-%d", fs_key);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_RESOLVE_HW;
key.fs_key = fs_key;
result = radv_meta_get_noop_pipeline_layout(device, layout_out);
if (result != VK_SUCCESS)
@ -139,7 +146,7 @@ get_pipeline(struct radv_device *device, unsigned fs_key, VkPipeline *pipeline_o
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);

48
src/amd/vulkan/meta/radv_meta_resolve_cs.c
View file

@ -168,7 +168,7 @@ build_depth_stencil_resolve_compute_shader(struct radv_device *dev, int samples,
static VkResult
create_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-resolve-cs-layout";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_RESOLVE_CS;
const VkDescriptorSetLayoutBinding bindings[] = {
{
@ -197,10 +197,17 @@ create_layout(struct radv_device *device, VkPipelineLayout *layout_out)
.size = 16,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
struct radv_resolve_color_cs_key {
enum radv_meta_object_key_type type;
bool is_integer;
bool is_srgb;
uint8_t samples;
};
static VkResult
get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *src_iview, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
@ -208,16 +215,20 @@ get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *s
const bool is_integer = vk_format_is_int(src_iview->vk.format);
const bool is_srgb = vk_format_is_srgb(src_iview->vk.format);
uint32_t samples = src_iview->image->vk.samples;
char key_data[64];
struct radv_resolve_color_cs_key key;
VkResult result;
result = create_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-color-resolve-cs--%d-%d-%d", is_integer, is_srgb, samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_RESOLVE_COLOR_CS;
key.is_integer = is_integer;
key.is_srgb = is_srgb;
key.samples = samples;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -240,8 +251,8 @@ get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *s
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;
@ -300,6 +311,13 @@ emit_resolve(struct radv_cmd_buffer *cmd_buffer, struct radv_image_view *src_ivi
radv_unaligned_dispatch(cmd_buffer, resolve_extent->width, resolve_extent->height, 1);
}
struct radv_resolve_ds_cs_key {
enum radv_meta_object_key_type type;
uint8_t index;
uint8_t samples;
VkResolveModeFlagBits resolve_mode;
};
static VkResult
get_depth_stencil_resolve_pipeline(struct radv_device *device, int samples, VkImageAspectFlags aspects,
VkResolveModeFlagBits resolve_mode, VkPipeline *pipeline_out,
@ -307,16 +325,20 @@ get_depth_stencil_resolve_pipeline(struct radv_device *device, int samples, VkIm
{
const int index = aspects == VK_IMAGE_ASPECT_DEPTH_BIT ? DEPTH_RESOLVE : STENCIL_RESOLVE;
char key_data[64];
struct radv_resolve_ds_cs_key key;
VkResult result;
result = create_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-ds-resolve-cs-%d-%d-%d", index, resolve_mode, samples);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_RESOLVE_DS_CS;
key.index = index;
key.samples = samples;
key.resolve_mode = resolve_mode;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -339,8 +361,8 @@ get_depth_stencil_resolve_pipeline(struct radv_device *device, int samples, VkIm
.layout = *layout_out,
};
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, key_data,
strlen(key_data), pipeline_out);
result = vk_meta_create_compute_pipeline(&device->vk, &device->meta_state.device, &pipeline_info, &key, sizeof(key),
pipeline_out);
ralloc_free(cs);
return result;

42
src/amd/vulkan/meta/radv_meta_resolve_fs.c
View file

@ -49,7 +49,7 @@ build_resolve_fragment_shader(struct radv_device *dev, bool is_integer, int samp
static VkResult
create_layout(struct radv_device *device, VkPipelineLayout *layout_out)
{
const char *key_data = "radv-resolve-fs";
enum radv_meta_object_key_type key = RADV_META_OBJECT_KEY_RESOLVE_FS;
const VkDescriptorSetLayoutBinding binding = {.binding = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
@ -68,8 +68,8 @@ create_layout(struct radv_device *device, VkPipelineLayout *layout_out)
.size = 8,
};
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, key_data,
strlen(key_data), layout_out);
return vk_meta_get_pipeline_layout(&device->vk, &device->meta_state.device, &desc_info, &pc_range, &key, sizeof(key),
layout_out);
}
enum { DEPTH_RESOLVE, STENCIL_RESOLVE };
@ -154,22 +154,33 @@ build_depth_stencil_resolve_fragment_shader(struct radv_device *dev, int samples
return b.shader;
}
struct radv_resolve_ds_fs_key {
enum radv_meta_object_key_type type;
uint32_t samples;
VkImageAspectFlags aspects;
VkResolveModeFlagBits resolve_mode;
};
static VkResult
get_depth_stencil_resolve_pipeline(struct radv_device *device, int samples, VkImageAspectFlags aspects,
VkResolveModeFlagBits resolve_mode, VkPipeline *pipeline_out,
VkPipelineLayout *layout_out)
{
const int index = aspects == VK_IMAGE_ASPECT_DEPTH_BIT ? DEPTH_RESOLVE : STENCIL_RESOLVE;
char key_data[64];
struct radv_resolve_ds_fs_key key;
VkResult result;
result = create_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-ds-resolve-fs-%d-%d-%d", aspects, samples, resolve_mode);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_RESOLVE_DS_FS;
key.samples = samples;
key.aspects = aspects;
key.resolve_mode = resolve_mode;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -289,13 +300,19 @@ get_depth_stencil_resolve_pipeline(struct radv_device *device, int samples, VkIm
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);
return result;
}
struct radv_resolve_color_fs_key {
enum radv_meta_object_key_type type;
uint32_t samples;
uint32_t fs_key;
};
static VkResult
get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *src_iview,
struct radv_image_view *dst_iview, VkPipeline *pipeline_out, VkPipelineLayout *layout_out)
@ -304,16 +321,19 @@ get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *s
const uint32_t samples = src_iview->image->vk.samples;
const VkFormat format = radv_fs_key_format_exemplars[fs_key];
const bool is_integer = vk_format_is_int(format);
char key_data[64];
struct radv_resolve_color_fs_key key;
VkResult result;
result = create_layout(device, layout_out);
if (result != VK_SUCCESS)
return result;
snprintf(key_data, sizeof(key_data), "radv-color-resolve-fs-%d-%d", samples, fs_key);
memset(&key, 0, sizeof(key));
key.type = RADV_META_OBJECT_KEY_RESOLVE_COLOR_FS;
key.samples = samples;
key.fs_key = fs_key;
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, key_data, strlen(key_data));
VkPipeline pipeline_from_cache = vk_meta_lookup_pipeline(&device->meta_state.device, &key, sizeof(key));
if (pipeline_from_cache != VK_NULL_HANDLE) {
*pipeline_out = pipeline_from_cache;
return VK_SUCCESS;
@ -403,7 +423,7 @@ get_color_resolve_pipeline(struct radv_device *device, struct radv_image_view *s
};
result = vk_meta_create_graphics_pipeline(&device->vk, &device->meta_state.device, &pipeline_create_info, &render,
key_data, strlen(key_data), pipeline_out);
&key, sizeof(key), pipeline_out);
ralloc_free(vs_module);
ralloc_free(fs_module);