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

zink: split dirty_shader_stages for gfx and compute

Browse source 
this simplifies/clarifies a lot of related code

Reviewed-by: Adam Jackson <ajax@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18786>
This commit is contained in:
Mike Blumenkrantz 2022-09-02 11:07:34 -04:00 • committed by Marge Bot
parent 49866c4f77
commit 76ae28e69c
5 changed files with 32 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/gallium/drivers/zink/zink_context.c
View file

@ -681,7 +681,7 @@ update_nonseamless_shader_key(struct zink_context *ctx, gl_shader_stage pstage)
const uint32_t new_mask = ctx->di.emulate_nonseamless[pstage] & ctx->di.cubes[pstage];
if (pstage == MESA_SHADER_COMPUTE) {
if (ctx->compute_pipeline_state.key.base.nonseamless_cube_mask != new_mask)
ctx->dirty_shader_stages |= BITFIELD_BIT(pstage);
ctx->compute_dirty = true;
ctx->compute_pipeline_state.key.base.nonseamless_cube_mask = new_mask;
} else {
if (zink_get_shader_key_base(ctx, pstage)->nonseamless_cube_mask != new_mask)
@ -1310,7 +1310,10 @@ zink_set_inlinable_constants(struct pipe_context *pctx,
if (!(ctx->inlinable_uniforms_valid_mask & bit) ||
memcmp(inlinable_uniforms, values, num_values * 4)) {
memcpy(inlinable_uniforms, values, num_values * 4);
ctx->dirty_shader_stages |= bit;
if (shader == MESA_SHADER_COMPUTE)
ctx->compute_dirty = true;
else
ctx->dirty_gfx_stages |= bit;
ctx->inlinable_uniforms_valid_mask |= bit;
key->inline_uniforms = true;
}
@ -1350,11 +1353,12 @@ invalidate_inlined_uniforms(struct zink_context *ctx, gl_shader_stage pstage)
if (!(ctx->inlinable_uniforms_valid_mask & bit))
return;
ctx->inlinable_uniforms_valid_mask &= ~bit;
ctx->dirty_shader_stages |= bit;
if (pstage == MESA_SHADER_COMPUTE)
if (pstage == MESA_SHADER_COMPUTE) {
ctx->compute_dirty = true;
return;
}
assert(!zink_screen(ctx->base.screen)->optimal_keys);
ctx->dirty_gfx_stages |= bit;
struct zink_shader_key *key = &ctx->gfx_pipeline_state.shader_keys.key[pstage];
key->inline_uniforms = false;
}

4
src/gallium/drivers/zink/zink_draw.cpp
View file

@ -890,10 +890,10 @@ zink_launch_grid(struct pipe_context *pctx, const struct pipe_grid_info *info)
zink_update_descriptor_refs(ctx, true);
zink_batch_reference_program(&ctx->batch, &ctx->curr_compute->base);
}
if (ctx->dirty_shader_stages & BITFIELD_BIT(MESA_SHADER_COMPUTE)) {
if (ctx->compute_dirty) {
/* update inlinable constants */
zink_update_compute_program(ctx);
ctx->dirty_shader_stages &= ~BITFIELD_BIT(MESA_SHADER_COMPUTE);
ctx->compute_dirty = false;
}
VkPipeline pipeline = zink_get_compute_pipeline(screen, ctx->curr_compute,

30
src/gallium/drivers/zink/zink_program.c
View file

@ -527,11 +527,11 @@ update_gfx_program_nonseamless(struct zink_context *ctx, struct zink_gfx_program
struct zink_screen *screen = zink_screen(ctx->base.screen);
if (screen->driconf.inline_uniforms)
update_gfx_shader_modules(ctx, screen, prog,
ctx->dirty_shader_stages & prog->stages_present, &ctx->gfx_pipeline_state,
ctx->dirty_gfx_stages & prog->stages_present, &ctx->gfx_pipeline_state,
true, has_nonseamless);
else
update_gfx_shader_modules(ctx, screen, prog,
ctx->dirty_shader_stages & prog->stages_present, &ctx->gfx_pipeline_state,
ctx->dirty_gfx_stages & prog->stages_present, &ctx->gfx_pipeline_state,
false, has_nonseamless);
}
@ -551,7 +551,7 @@ zink_gfx_program_update(struct zink_context *ctx)
struct zink_screen *screen = zink_screen(ctx->base.screen);
if (ctx->last_vertex_stage_dirty) {
gl_shader_stage pstage = ctx->last_vertex_stage->nir->info.stage;
ctx->dirty_shader_stages |= BITFIELD_BIT(pstage);
ctx->dirty_gfx_stages |= BITFIELD_BIT(pstage);
if (!screen->optimal_keys) {
memcpy(&ctx->gfx_pipeline_state.shader_keys.key[pstage].key.vs_base,
&ctx->gfx_pipeline_state.shader_keys.last_vertex.key.vs_base,
@ -572,25 +572,25 @@ zink_gfx_program_update(struct zink_context *ctx)
if (screen->optimal_keys) {
ctx->gfx_pipeline_state.optimal_key = ctx->gfx_pipeline_state.shader_keys_optimal.key.val;
if (ctx->gfx_pipeline_state.optimal_key != prog->last_variant_hash) {
ctx->dirty_shader_stages |= BITFIELD_BIT(ctx->last_vertex_stage->nir->info.stage);
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
ctx->dirty_gfx_stages |= BITFIELD_BIT(ctx->last_vertex_stage->nir->info.stage);
ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
if (prog->shaders[MESA_SHADER_TESS_CTRL] && prog->shaders[MESA_SHADER_TESS_CTRL]->is_generated)
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_TESS_CTRL);
ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_TESS_CTRL);
update_gfx_shader_modules_optimal(ctx, screen, prog,
ctx->dirty_shader_stages & prog->stages_present,
ctx->dirty_gfx_stages & prog->stages_present,
&ctx->gfx_pipeline_state);
}
} else {
for (unsigned i = 0; i < ZINK_GFX_SHADER_COUNT; i++) {
if (prog->stages_present & ~ctx->dirty_shader_stages & BITFIELD_BIT(i))
if (prog->stages_present & ~ctx->dirty_gfx_stages & BITFIELD_BIT(i))
ctx->gfx_pipeline_state.modules[i] = prog->modules[i];
}
/* ensure variants are always updated if keys have changed since last use */
ctx->dirty_shader_stages |= prog->stages_present;
ctx->dirty_gfx_stages |= prog->stages_present;
update_gfx_program(ctx, prog);
}
} else {
ctx->dirty_shader_stages |= bits;
ctx->dirty_gfx_stages |= bits;
prog = zink_create_gfx_program(ctx, ctx->gfx_stages, ctx->gfx_pipeline_state.dyn_state2.vertices_per_patch);
_mesa_hash_table_insert_pre_hashed(ht, hash, prog->shaders, prog);
if (screen->optimal_keys)
@ -606,13 +606,13 @@ zink_gfx_program_update(struct zink_context *ctx)
ctx->curr_program = prog;
ctx->gfx_pipeline_state.final_hash ^= ctx->curr_program->last_variant_hash;
ctx->gfx_dirty = false;
} else if (ctx->dirty_shader_stages & bits) {
} else if (ctx->dirty_gfx_stages & bits) {
/* remove old hash */
ctx->gfx_pipeline_state.final_hash ^= ctx->curr_program->last_variant_hash;
if (screen->optimal_keys) {
if (ctx->gfx_pipeline_state.optimal_key != ctx->curr_program->last_variant_hash)
update_gfx_shader_modules_optimal(ctx, screen, ctx->curr_program,
ctx->dirty_shader_stages & ctx->curr_program->stages_present,
ctx->dirty_gfx_stages & ctx->curr_program->stages_present,
&ctx->gfx_pipeline_state);
} else {
update_gfx_program(ctx, ctx->curr_program);
@ -620,7 +620,7 @@ zink_gfx_program_update(struct zink_context *ctx)
/* apply new hash */
ctx->gfx_pipeline_state.final_hash ^= ctx->curr_program->last_variant_hash;
}
ctx->dirty_shader_stages &= ~bits;
ctx->dirty_gfx_stages &= ~bits;
}
static void
@ -1260,7 +1260,7 @@ bind_last_vertex_stage(struct zink_context *ctx)
if (!zink_screen(ctx->base.screen)->optimal_keys) {
if (old != MESA_SHADER_STAGES) {
memset(&ctx->gfx_pipeline_state.shader_keys.key[old].key.vs_base, 0, sizeof(struct zink_vs_key_base));
ctx->dirty_shader_stages |= BITFIELD_BIT(old);
ctx->dirty_gfx_stages |= BITFIELD_BIT(old);
} else {
/* always unset vertex shader values when changing to a non-vs last stage */
memset(&ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_VERTEX].key.vs_base, 0, sizeof(struct zink_vs_key_base));
@ -1431,7 +1431,7 @@ zink_bind_cs_state(struct pipe_context *pctx,
ctx->compute_pipeline_state.module = ctx->curr_compute->curr->shader;
ctx->compute_pipeline_state.final_hash ^= ctx->compute_pipeline_state.module_hash;
if (ctx->compute_pipeline_state.key.base.nonseamless_cube_mask)
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_COMPUTE);
ctx->compute_dirty = true;
}
zink_select_launch_grid(ctx);
}

8
src/gallium/drivers/zink/zink_program.h
View file

@ -223,7 +223,7 @@ zink_program_has_descriptors(const struct zink_program *pg)
static inline struct zink_fs_key *
zink_set_fs_key(struct zink_context *ctx)
{
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_FRAGMENT);
return zink_screen(ctx->base.screen)->optimal_keys ?
&ctx->gfx_pipeline_state.shader_keys_optimal.key.fs :
&ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_FRAGMENT].key.fs;
@ -245,7 +245,7 @@ zink_set_tcs_key_patches(struct zink_context *ctx, uint8_t patch_vertices)
&ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_TESS_CTRL].key.tcs;
if (tcs->patch_vertices == patch_vertices)
return false;
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_TESS_CTRL);
ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_TESS_CTRL);
tcs->patch_vertices = patch_vertices;
return true;
}
@ -264,7 +264,7 @@ zink_update_fs_key_samples(struct zink_context *ctx);
static inline struct zink_vs_key *
zink_set_vs_key(struct zink_context *ctx)
{
ctx->dirty_shader_stages |= BITFIELD_BIT(MESA_SHADER_VERTEX);
ctx->dirty_gfx_stages |= BITFIELD_BIT(MESA_SHADER_VERTEX);
assert(!zink_screen(ctx->base.screen)->optimal_keys);
return &ctx->gfx_pipeline_state.shader_keys.key[MESA_SHADER_VERTEX].key.vs;
}
@ -316,7 +316,7 @@ zink_get_shader_key_base(struct zink_context *ctx, gl_shader_stage pstage)
static inline struct zink_shader_key_base *
zink_set_shader_key_base(struct zink_context *ctx, gl_shader_stage pstage)
{
ctx->dirty_shader_stages |= BITFIELD_BIT(pstage);
ctx->dirty_gfx_stages |= BITFIELD_BIT(pstage);
assert(!zink_screen(ctx->base.screen)->optimal_keys);
return &ctx->gfx_pipeline_state.shader_keys.key[pstage].base;
}

3
src/gallium/drivers/zink/zink_types.h
View file

@ -1426,8 +1426,9 @@ struct zink_context {
struct zink_compute_program *curr_compute;
unsigned shader_stages : ZINK_GFX_SHADER_COUNT; /* mask of bound gfx shader stages */
unsigned dirty_shader_stages : 6; /* mask of changed shader stages */
uint8_t dirty_gfx_stages; /* mask of changed gfx shader stages */
bool last_vertex_stage_dirty;
bool compute_dirty;
struct {
VkRenderingAttachmentInfo attachments[PIPE_MAX_COLOR_BUFS + 2]; //+depth, +stencil