OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

panfrost: Make the pan_blend logic panfrost_device-agnostic

Browse Source 
We keep embedding a blend shader cache in panfrost_device, but now we
have pan_blend source files that can be used without a panfrost_device
object.

Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
Reviewed-by: Constantine Shablya <constantine.shablya@collabora.com>
Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26698>
This commit is contained in:
Boris Brezillon
2023-12-07 12:16:45 +01:00
committed by Marge Bot
parent 8a42913c23
commit 3e85e3ce08
8 changed files with 38 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/gallium/drivers/panfrost/pan_context.c
View File

@@ -222,7 +222,8 @@ panfrost_get_blend(struct panfrost_batch *batch, unsigned rti,
pthread_mutex_lock(&dev->blend_shaders.lock); pthread_mutex_lock(&dev->blend_shaders.lock);
struct pan_blend_shader_variant *shader = struct pan_blend_shader_variant *shader =
pan_screen(ctx->base.screen) pan_screen(ctx->base.screen)
->vtbl.get_blend_shader(dev, &pan_blend, col0_type, col1_type, rti); ->vtbl.get_blend_shader(&dev->blend_shaders, &pan_blend, col0_type,
col1_type, rti);
/* Size check and upload */ /* Size check and upload */
unsigned offset = *shader_offset; unsigned offset = *shader_offset;

5
src/gallium/drivers/panfrost/pan_screen.c
View File

@@ -776,7 +776,7 @@ panfrost_destroy_screen(struct pipe_screen *pscreen)
panfrost_resource_screen_destroy(pscreen); panfrost_resource_screen_destroy(pscreen);
panfrost_pool_cleanup(&screen->blitter.bin_pool); panfrost_pool_cleanup(&screen->blitter.bin_pool);
panfrost_pool_cleanup(&screen->blitter.desc_pool); panfrost_pool_cleanup(&screen->blitter.desc_pool);
pan_blend_shaders_cleanup(dev); pan_blend_shader_cache_cleanup(&dev->blend_shaders);
if (screen->vtbl.screen_destroy) if (screen->vtbl.screen_destroy)
screen->vtbl.screen_destroy(pscreen); screen->vtbl.screen_destroy(pscreen);
@@ -883,7 +883,8 @@ panfrost_create_screen(int fd, const struct pipe_screen_config *config,
screen->base.set_damage_region = panfrost_resource_set_damage_region; screen->base.set_damage_region = panfrost_resource_set_damage_region;
panfrost_resource_screen_init(&screen->base); panfrost_resource_screen_init(&screen->base);
pan_blend_shaders_init(dev); pan_blend_shader_cache_init(&dev->blend_shaders,
panfrost_device_gpu_id(dev));
panfrost_disk_cache_init(screen); panfrost_disk_cache_init(screen);

2
src/gallium/drivers/panfrost/pan_screen.h
View File

@@ -78,7 +78,7 @@ struct panfrost_vtable {
/* Get blend shader */ /* Get blend shader */
struct pan_blend_shader_variant *(*get_blend_shader)( struct pan_blend_shader_variant *(*get_blend_shader)(
const struct panfrost_device *, const struct pan_blend_state *, struct pan_blend_shader_cache *cache, const struct pan_blend_state *,
nir_alu_type, nir_alu_type, unsigned rt); nir_alu_type, nir_alu_type, unsigned rt);
/* Shader compilation methods */ /* Shader compilation methods */

29
src/panfrost/lib/pan_blend.c
View File

@@ -482,17 +482,20 @@ pan_blend_shader_key_equal(const void *a, const void *b)
} }
void void
pan_blend_shaders_init(struct panfrost_device *dev) pan_blend_shader_cache_init(struct pan_blend_shader_cache *cache,
unsigned gpu_id)
{ {
dev->blend_shaders.shaders = _mesa_hash_table_create( cache->gpu_id = gpu_id;
NULL, pan_blend_shader_key_hash, pan_blend_shader_key_equal); cache->shaders = _mesa_hash_table_create(NULL, pan_blend_shader_key_hash,
pthread_mutex_init(&dev->blend_shaders.lock, NULL); pan_blend_shader_key_equal);
pthread_mutex_init(&cache->lock, NULL);
} }
void void
pan_blend_shaders_cleanup(struct panfrost_device *dev) pan_blend_shader_cache_cleanup(struct pan_blend_shader_cache *cache)
{ {
_mesa_hash_table_destroy(dev->blend_shaders.shaders, NULL); _mesa_hash_table_destroy(cache->shaders, NULL);
pthread_mutex_destroy(&cache->lock);
} }
#else /* ifndef PAN_ARCH */ #else /* ifndef PAN_ARCH */
@@ -806,7 +809,7 @@ GENX(pan_inline_rt_conversion)(nir_shader *s, enum pipe_format *formats)
#endif #endif
struct pan_blend_shader_variant * struct pan_blend_shader_variant *
GENX(pan_blend_get_shader_locked)(const struct panfrost_device *dev, GENX(pan_blend_get_shader_locked)(struct pan_blend_shader_cache *cache,
const struct pan_blend_state *state, const struct pan_blend_state *state,
nir_alu_type src0_type, nir_alu_type src0_type,
nir_alu_type src1_type, unsigned rt) nir_alu_type src1_type, unsigned rt)
@@ -824,19 +827,19 @@ GENX(pan_blend_get_shader_locked)(const struct panfrost_device *dev,
}; };
/* Blend shaders should only be used for blending on Bifrost onwards */ /* Blend shaders should only be used for blending on Bifrost onwards */
assert(dev->arch <= 5 || state->logicop_enable || assert(PAN_ARCH <= 5 || state->logicop_enable ||
!pan_blend_is_opaque(state->rts[rt].equation)); !pan_blend_is_opaque(state->rts[rt].equation));
assert(state->rts[rt].equation.color_mask != 0); assert(state->rts[rt].equation.color_mask != 0);
struct hash_entry *he = struct hash_entry *he =
_mesa_hash_table_search(dev->blend_shaders.shaders, &key); _mesa_hash_table_search(cache->shaders, &key);
struct pan_blend_shader *shader = he ? he->data : NULL; struct pan_blend_shader *shader = he ? he->data : NULL;
if (!shader) { if (!shader) {
shader = rzalloc(dev->blend_shaders.shaders, struct pan_blend_shader); shader = rzalloc(cache->shaders, struct pan_blend_shader);
shader->key = key; shader->key = key;
list_inithead(&shader->variants); list_inithead(&shader->variants);
_mesa_hash_table_insert(dev->blend_shaders.shaders, &shader->key, shader); _mesa_hash_table_insert(cache->shaders, &shader->key, shader);
} }
list_for_each_entry(struct pan_blend_shader_variant, iter, &shader->variants, list_for_each_entry(struct pan_blend_shader_variant, iter, &shader->variants,
@@ -868,7 +871,7 @@ GENX(pan_blend_get_shader_locked)(const struct panfrost_device *dev,
/* Compile the NIR shader */ /* Compile the NIR shader */
struct panfrost_compile_inputs inputs = { struct panfrost_compile_inputs inputs = {
.gpu_id = panfrost_device_gpu_id(dev), .gpu_id = cache->gpu_id,
.is_blend = true, .is_blend = true,
.blend.nr_samples = key.nr_samples, .blend.nr_samples = key.nr_samples,
}; };
@@ -889,7 +892,7 @@ GENX(pan_blend_get_shader_locked)(const struct panfrost_device *dev,
#else #else
NIR_PASS_V(nir, pan_lower_framebuffer, rt_formats, NIR_PASS_V(nir, pan_lower_framebuffer, rt_formats,
pan_raw_format_mask_midgard(rt_formats), MAX2(key.nr_samples, 1), pan_raw_format_mask_midgard(rt_formats), MAX2(key.nr_samples, 1),
panfrost_device_gpu_id(dev) < 0x700); cache->gpu_id < 0x700);
#endif #endif
GENX(pan_shader_compile)(nir, &inputs, &variant->binary, &info); GENX(pan_shader_compile)(nir, &inputs, &variant->binary, &info);

14
src/panfrost/lib/pan_blend.h
View File

@@ -35,7 +35,12 @@
#include "panfrost/util/pan_ir.h" #include "panfrost/util/pan_ir.h"
struct MALI_BLEND_EQUATION; struct MALI_BLEND_EQUATION;
struct panfrost_device;
struct pan_blend_shader_cache {
unsigned gpu_id;
struct hash_table *shaders;
pthread_mutex_t lock;
};
struct pan_blend_equation { struct pan_blend_equation {
unsigned blend_enable : 1; unsigned blend_enable : 1;
@@ -143,9 +148,10 @@ void pan_blend_to_fixed_function_equation(const struct pan_blend_equation eq,
uint32_t pan_pack_blend(const struct pan_blend_equation equation); uint32_t pan_pack_blend(const struct pan_blend_equation equation);
void pan_blend_shaders_init(struct panfrost_device *dev); void pan_blend_shader_cache_init(struct pan_blend_shader_cache *cache,
unsigned gpu_id);
void pan_blend_shaders_cleanup(struct panfrost_device *dev); void pan_blend_shader_cache_cleanup(struct pan_blend_shader_cache *cache);
#ifdef PAN_ARCH #ifdef PAN_ARCH
@@ -160,7 +166,7 @@ bool GENX(pan_inline_rt_conversion)(nir_shader *s, enum pipe_format *formats);
* you're done with the shader variant object. * you're done with the shader variant object.
*/ */
struct pan_blend_shader_variant *GENX(pan_blend_get_shader_locked)( struct pan_blend_shader_variant *GENX(pan_blend_get_shader_locked)(
const struct panfrost_device *dev, const struct pan_blend_state *state, struct pan_blend_shader_cache *cache, const struct pan_blend_state *state,
nir_alu_type src0_type, nir_alu_type src1_type, unsigned rt); nir_alu_type src0_type, nir_alu_type src1_type, unsigned rt);
#endif #endif

2
src/panfrost/lib/pan_blitter.c
View File

@@ -359,7 +359,7 @@ pan_blitter_get_blend_shaders(struct panfrost_device *dev, unsigned rt_count,
pthread_mutex_lock(&dev->blend_shaders.lock); pthread_mutex_lock(&dev->blend_shaders.lock);
struct pan_blend_shader_variant *b = GENX(pan_blend_get_shader_locked)( struct pan_blend_shader_variant *b = GENX(pan_blend_get_shader_locked)(
dev, &blend_state, blit_shader->blend_types[i], &dev->blend_shaders, &blend_state, blit_shader->blend_types[i],
nir_type_float32, /* unused */ nir_type_float32, /* unused */
i); i);

8
src/panfrost/lib/pan_device.h
View File

@@ -38,6 +38,7 @@
#include "util/u_dynarray.h" #include "util/u_dynarray.h"
#include "panfrost/util/pan_ir.h" #include "panfrost/util/pan_ir.h"
#include "pan_blend.h"
#include "pan_pool.h" #include "pan_pool.h"
#include "pan_util.h" #include "pan_util.h"
@@ -76,11 +77,6 @@ struct pan_blitter {
} rsds; } rsds;
}; };
struct pan_blend_shaders {
struct hash_table *shaders;
pthread_mutex_t lock;
};
struct pan_indirect_dispatch { struct pan_indirect_dispatch {
struct panfrost_ubo_push push; struct panfrost_ubo_push push;
struct panfrost_bo *bin; struct panfrost_bo *bin;
@@ -197,7 +193,7 @@ struct panfrost_device {
} bo_cache; } bo_cache;
struct pan_blitter blitter; struct pan_blitter blitter;
struct pan_blend_shaders blend_shaders; struct pan_blend_shader_cache blend_shaders;
struct pan_indirect_dispatch indirect_dispatch; struct pan_indirect_dispatch indirect_dispatch;
/* Tiler heap shared across all tiler jobs, allocated against the /* Tiler heap shared across all tiler jobs, allocated against the

5
src/panfrost/vulkan/panvk_vX_meta_blit.c
View File

@@ -226,7 +226,8 @@ panvk_per_arch(meta_blit_init)(struct panvk_physical_device *dev)
false); false);
panvk_pool_init(&dev->meta.blitter.desc_pool, &dev->pdev, NULL, 0, 16 * 1024, panvk_pool_init(&dev->meta.blitter.desc_pool, &dev->pdev, NULL, 0, 16 * 1024,
"panvk_meta blitter descriptor pool", false); "panvk_meta blitter descriptor pool", false);
pan_blend_shaders_init(&dev->pdev); pan_blend_shader_cache_init(&dev->pdev.blend_shaders,
panfrost_device_gpu_id(&dev->pdev));
GENX(pan_blitter_init) GENX(pan_blitter_init)
(&dev->pdev, &dev->meta.blitter.bin_pool.base, (&dev->pdev, &dev->meta.blitter.bin_pool.base,
&dev->meta.blitter.desc_pool.base); &dev->meta.blitter.desc_pool.base);
@@ -236,7 +237,7 @@ void
panvk_per_arch(meta_blit_cleanup)(struct panvk_physical_device *dev) panvk_per_arch(meta_blit_cleanup)(struct panvk_physical_device *dev)
{ {
GENX(pan_blitter_cleanup)(&dev->pdev); GENX(pan_blitter_cleanup)(&dev->pdev);
pan_blend_shaders_cleanup(&dev->pdev); pan_blend_shader_cache_cleanup(&dev->pdev.blend_shaders);
panvk_pool_cleanup(&dev->meta.blitter.desc_pool); panvk_pool_cleanup(&dev->meta.blitter.desc_pool);
panvk_pool_cleanup(&dev->meta.blitter.bin_pool); panvk_pool_cleanup(&dev->meta.blitter.bin_pool);
} }