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

intel: use shader source hash in INTEL_MEASURE

Browse source 
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23942>
This commit is contained in:
Felix DeGrood 2023-06-28 21:15:45 +00:00 • committed by Marge Bot
parent 49182271e3
commit 6ac8a9a030
4 changed files with 54 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/gallium/drivers/iris/iris_measure.c
View file

@ -137,6 +137,12 @@ iris_destroy_batch_measure(struct iris_measure_batch *batch)
free(batch);
}
static uint32_t
fetch_hash(const struct iris_uncompiled_shader *uncompiled)
{
return (uncompiled) ? uncompiled->source_hash : 0;
}
static void
measure_start_snapshot(struct iris_context *ice,
struct iris_batch *batch,
@ -202,13 +208,13 @@ measure_start_snapshot(struct iris_context *ice,
snapshot->renderpass = renderpass;
if (type == INTEL_SNAPSHOT_COMPUTE) {
snapshot->cs = (uintptr_t) ice->shaders.prog[MESA_SHADER_COMPUTE];
} else {
snapshot->vs = (uintptr_t) ice->shaders.prog[MESA_SHADER_VERTEX];
snapshot->tcs = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_CTRL];
snapshot->tes = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_EVAL];
snapshot->gs = (uintptr_t) ice->shaders.prog[MESA_SHADER_GEOMETRY];
snapshot->fs = (uintptr_t) ice->shaders.prog[MESA_SHADER_FRAGMENT];
snapshot->cs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_COMPUTE]);
} else if (type == INTEL_SNAPSHOT_DRAW) {
snapshot->vs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_VERTEX]);
snapshot->tcs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_CTRL]);
snapshot->tes = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_EVAL]);
snapshot->gs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_GEOMETRY]);
snapshot->fs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_FRAGMENT]);
}
}
@ -244,13 +250,13 @@ state_changed(const struct iris_context *ice,
uintptr_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0;
if (type == INTEL_SNAPSHOT_COMPUTE) {
cs = (uintptr_t) ice->shaders.prog[MESA_SHADER_COMPUTE];
cs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_COMPUTE]);
} else if (type == INTEL_SNAPSHOT_DRAW) {
vs = (uintptr_t) ice->shaders.prog[MESA_SHADER_VERTEX];
tcs = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_CTRL];
tes = (uintptr_t) ice->shaders.prog[MESA_SHADER_TESS_EVAL];
gs = (uintptr_t) ice->shaders.prog[MESA_SHADER_GEOMETRY];
fs = (uintptr_t) ice->shaders.prog[MESA_SHADER_FRAGMENT];
vs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_VERTEX]);
tcs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_CTRL]);
tes = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_TESS_EVAL]);
gs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_GEOMETRY]);
fs = fetch_hash(ice->shaders.uncompiled[MESA_SHADER_FRAGMENT]);
}
/* else blorp, all programs NULL */

27
src/intel/common/intel_measure.c
View file

@ -279,9 +279,9 @@ intel_measure_snapshot_string(enum intel_measure_snapshot_type type)
*/
bool
intel_measure_state_changed(const struct intel_measure_batch *batch,
uintptr_t vs, uintptr_t tcs, uintptr_t tes,
uintptr_t gs, uintptr_t fs, uintptr_t cs,
uintptr_t ms, uintptr_t ts)
uint32_t vs, uint32_t tcs, uint32_t tes,
uint32_t gs, uint32_t fs, uint32_t cs,
uint32_t ms, uint32_t ts)
{
if (batch->index == 0) {
/* always record the first event */
@ -320,14 +320,14 @@ intel_measure_state_changed(const struct intel_measure_batch *batch,
return true;
}
return (last_snap->vs != (uintptr_t) vs ||
last_snap->tcs != (uintptr_t) tcs ||
last_snap->tes != (uintptr_t) tes ||
last_snap->gs != (uintptr_t) gs ||
last_snap->fs != (uintptr_t) fs ||
last_snap->cs != (uintptr_t) cs ||
last_snap->ms != (uintptr_t) ms ||
last_snap->ts != (uintptr_t) ts);
return (last_snap->vs != vs ||
last_snap->tcs != tcs ||
last_snap->tes != tes ||
last_snap->gs != gs ||
last_snap->fs != fs ||
last_snap->cs != cs ||
last_snap->ms != ms ||
last_snap->ts != ts);
}
/**
@ -626,9 +626,8 @@ print_combined_results(struct intel_measure_device *measure_device,
start_result->frame, start_result->batch_count,
renderpass, start_result->event_index, event_count,
begin->event_name, begin->count,
(uint32_t)begin->vs, (uint32_t)begin->tcs, (uint32_t)begin->tes,
(uint32_t)begin->gs, (uint32_t)begin->fs, (uint32_t)begin->cs,
(uint32_t)begin->ms, (uint32_t)begin->ts,
begin->vs, begin->tcs, begin->tes, begin->gs,
begin->fs, begin->cs, begin->ms, begin->ts,
(double)duration_idle_ns / 1000.0,
(double)duration_time_ns / 1000.0);
}

8
src/intel/common/intel_measure.h
View file

@ -113,7 +113,7 @@ struct intel_measure_snapshot {
unsigned count, event_count;
const char* event_name;
uint32_t renderpass;
uintptr_t vs, tcs, tes, gs, fs, cs, ms, ts;
uint32_t vs, tcs, tes, gs, fs, cs, ms, ts;
/* for vulkan secondary command buffers */
struct intel_measure_batch *secondary;
};
@ -163,9 +163,9 @@ struct intel_measure_batch {
void intel_measure_init(struct intel_measure_device *device);
const char * intel_measure_snapshot_string(enum intel_measure_snapshot_type type);
bool intel_measure_state_changed(const struct intel_measure_batch *batch,
uintptr_t vs, uintptr_t tcs, uintptr_t tes,
uintptr_t gs, uintptr_t fs, uintptr_t cs,
uintptr_t ms, uintptr_t ts);
uint32_t vs, uint32_t tcs, uint32_t tes,
uint32_t gs, uint32_t fs, uint32_t cs,
uint32_t ms, uint32_t ts);
void intel_measure_frame_transition(unsigned frame);
bool intel_measure_ready(struct intel_measure_batch *batch);

36
src/intel/vulkan/anv_measure.c
View file

@ -152,17 +152,17 @@ anv_measure_start_snapshot(struct anv_cmd_buffer *cmd_buffer,
: measure->base.renderpass;
if (type == INTEL_SNAPSHOT_COMPUTE && cmd_buffer->state.compute.pipeline) {
snapshot->cs = (uintptr_t) cmd_buffer->state.compute.pipeline->cs;
} else if (cmd_buffer->state.gfx.pipeline) {
snapshot->cs = cmd_buffer->state.compute.pipeline->source_hash;
} else if (type == INTEL_SNAPSHOT_DRAW && cmd_buffer->state.gfx.pipeline) {
const struct anv_graphics_pipeline *pipeline =
cmd_buffer->state.gfx.pipeline;
snapshot->vs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_VERTEX];
snapshot->tcs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TESS_CTRL];
snapshot->tes = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TESS_EVAL];
snapshot->gs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_GEOMETRY];
snapshot->fs = (uintptr_t) pipeline->base.shaders[MESA_SHADER_FRAGMENT];
snapshot->ms = (uintptr_t) pipeline->base.shaders[MESA_SHADER_MESH];
snapshot->ts = (uintptr_t) pipeline->base.shaders[MESA_SHADER_TASK];
snapshot->vs = pipeline->base.source_hashes[MESA_SHADER_VERTEX];
snapshot->tcs = pipeline->base.source_hashes[MESA_SHADER_TESS_CTRL];
snapshot->tes = pipeline->base.source_hashes[MESA_SHADER_TESS_EVAL];
snapshot->gs = pipeline->base.source_hashes[MESA_SHADER_GEOMETRY];
snapshot->fs = pipeline->base.source_hashes[MESA_SHADER_FRAGMENT];
snapshot->ms = pipeline->base.source_hashes[MESA_SHADER_MESH];
snapshot->ts = pipeline->base.source_hashes[MESA_SHADER_TASK];
}
}
@ -197,7 +197,7 @@ static bool
state_changed(struct anv_cmd_buffer *cmd_buffer,
enum intel_measure_snapshot_type type)
{
uintptr_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0, ms=0, ts=0;
uint32_t vs=0, tcs=0, tes=0, gs=0, fs=0, cs=0, ms=0, ts=0;
if (cmd_buffer->usage_flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)
/* can't record timestamps in this mode */
@ -207,17 +207,17 @@ state_changed(struct anv_cmd_buffer *cmd_buffer,
const struct anv_compute_pipeline *cs_pipe =
cmd_buffer->state.compute.pipeline;
assert(cs_pipe);
cs = (uintptr_t)cs_pipe->cs;
cs = cs_pipe->source_hash;
} else if (type == INTEL_SNAPSHOT_DRAW) {
const struct anv_graphics_pipeline *gfx = cmd_buffer->state.gfx.pipeline;
assert(gfx);
vs = (uintptr_t) gfx->base.shaders[MESA_SHADER_VERTEX];
tcs = (uintptr_t) gfx->base.shaders[MESA_SHADER_TESS_CTRL];
tes = (uintptr_t) gfx->base.shaders[MESA_SHADER_TESS_EVAL];
gs = (uintptr_t) gfx->base.shaders[MESA_SHADER_GEOMETRY];
fs = (uintptr_t) gfx->base.shaders[MESA_SHADER_FRAGMENT];
ms = (uintptr_t) gfx->base.shaders[MESA_SHADER_MESH];
ts = (uintptr_t) gfx->base.shaders[MESA_SHADER_TASK];
vs = gfx->base.source_hashes[MESA_SHADER_VERTEX];
tcs = gfx->base.source_hashes[MESA_SHADER_TESS_CTRL];
tes = gfx->base.source_hashes[MESA_SHADER_TESS_EVAL];
gs = gfx->base.source_hashes[MESA_SHADER_GEOMETRY];
fs = gfx->base.source_hashes[MESA_SHADER_FRAGMENT];
ms = gfx->base.source_hashes[MESA_SHADER_MESH];
ts = gfx->base.source_hashes[MESA_SHADER_TASK];
}
/* else blorp, all programs NULL */