KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

radv,aco: rename radv_prolog_binary/radv_shader_prolog to shader_part 

The same structures and functions will be re-used for PS epilogs.

Signed-off-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Reviewed-by: Rhys Perry <pendingchaos02@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17084>
This commit is contained in:
Samuel Pitoiset 2022-06-16 16:32:56 +02:00 committed by Marge Bot
parent 5cce02325c
commit 6cab999d6a
8 changed files with 54 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/amd/compiler/aco_interface.cpp
View File

@ -293,7 +293,7 @@ aco_compile_vs_prolog(const struct aco_compiler_options* options,
const struct aco_shader_info* info,
const struct aco_vs_prolog_key* key,
const struct radv_shader_args* args,
struct radv_prolog_binary** binary)
struct radv_shader_part_binary** binary)
{
aco::init();
@ -318,7 +318,7 @@ aco_compile_vs_prolog(const struct aco_compiler_options* options,
unsigned exec_size = aco::emit_program(program.get(), code);
/* copy into binary */
size_t size = code.size() * sizeof(uint32_t) + sizeof(radv_prolog_binary);
size_t size = code.size() * sizeof(uint32_t) + sizeof(radv_shader_part_binary);
bool get_disasm = options->dump_shader || options->record_ir;
@ -328,19 +328,18 @@ aco_compile_vs_prolog(const struct aco_compiler_options* options,
size += disasm.size();
}
radv_prolog_binary* prolog_binary = (radv_prolog_binary*)calloc(size, 1);
radv_shader_part_binary* bin = (radv_shader_part_binary*)calloc(size, 1);
prolog_binary->num_sgprs = config.num_sgprs;
prolog_binary->num_vgprs = config.num_vgprs;
prolog_binary->num_preserved_sgprs = num_preserved_sgprs;
prolog_binary->code_size = code.size() * sizeof(uint32_t);
memcpy(prolog_binary->data, code.data(), prolog_binary->code_size);
bin->num_sgprs = config.num_sgprs;
bin->num_vgprs = config.num_vgprs;
bin->num_preserved_sgprs = num_preserved_sgprs;
bin->code_size = code.size() * sizeof(uint32_t);
memcpy(bin->data, code.data(), bin->code_size);
if (get_disasm) {
disasm.copy((char*)prolog_binary->data + prolog_binary->code_size,
disasm.size());
prolog_binary->disasm_size = disasm.size();
disasm.copy((char*)bin->data + bin->code_size, disasm.size());
bin->disasm_size = disasm.size();
}
*binary = prolog_binary;
*binary = bin;
}

2
src/amd/compiler/aco_interface.h
View File

@ -56,7 +56,7 @@ void aco_compile_vs_prolog(const struct aco_compiler_options* options,
const struct aco_shader_info* info,
const struct aco_vs_prolog_key* key,
const struct radv_shader_args* args,
struct radv_prolog_binary** binary);
struct radv_shader_part_binary** binary);
uint64_t aco_get_codegen_flags();

12
src/amd/vulkan/radv_cmd_buffer.c
View File

@ -745,7 +745,7 @@ radv_save_vertex_descriptors(struct radv_cmd_buffer *cmd_buffer, uint64_t vb_ptr
}
static void
radv_save_vs_prolog(struct radv_cmd_buffer *cmd_buffer, const struct radv_shader_prolog *prolog)
radv_save_vs_prolog(struct radv_cmd_buffer *cmd_buffer, const struct radv_shader_part *prolog)
{
struct radv_device *device = cmd_buffer->device;
uint32_t data[2];
@ -2811,7 +2811,7 @@ radv_cmp_vs_prolog(const void *a_, const void *b_)
return memcmp(a, b, header.key_size) == 0;
}
static struct radv_shader_prolog *
static struct radv_shader_part *
lookup_vs_prolog(struct radv_cmd_buffer *cmd_buffer, struct radv_shader *vs_shader,
uint32_t *nontrivial_divisors)
{
@ -2832,7 +2832,7 @@ lookup_vs_prolog(struct radv_cmd_buffer *cmd_buffer, struct radv_shader *vs_shad
const uint32_t misaligned_mask = chip == GFX6 || chip >= GFX10 ? cmd_buffer->state.vbo_misaligned_mask : 0;
/* try to use a pre-compiled prolog first */
struct radv_shader_prolog *prolog = NULL;
struct radv_shader_part *prolog = NULL;
if (pipeline->can_use_simple_input &&
(!vs_shader->info.vs.as_ls || !instance_rate_inputs) &&
!misaligned_mask && !state->alpha_adjust_lo && !state->alpha_adjust_hi) {
@ -2933,7 +2933,7 @@ lookup_vs_prolog(struct radv_cmd_buffer *cmd_buffer, struct radv_shader *vs_shad
prolog = radv_create_vs_prolog(device, &key);
uint32_t *key2 = malloc(key_size * 4);
if (!prolog || !key2) {
radv_prolog_destroy(device, prolog);
radv_shader_part_destroy(device, prolog);
free(key2);
u_rwlock_wrunlock(&device->vs_prologs_lock);
return NULL;
@ -2950,7 +2950,7 @@ lookup_vs_prolog(struct radv_cmd_buffer *cmd_buffer, struct radv_shader *vs_shad
static void
emit_prolog_regs(struct radv_cmd_buffer *cmd_buffer, struct radv_shader *vs_shader,
struct radv_shader_prolog *prolog, bool pipeline_is_dirty)
struct radv_shader_part *prolog, bool pipeline_is_dirty)
{
/* no need to re-emit anything in this case */
if (cmd_buffer->state.emitted_vs_prolog == prolog && !pipeline_is_dirty)
@ -3059,7 +3059,7 @@ radv_emit_vertex_input(struct radv_cmd_buffer *cmd_buffer, bool pipeline_is_dirt
return;
uint32_t nontrivial_divisors;
struct radv_shader_prolog *prolog =
struct radv_shader_part *prolog =
lookup_vs_prolog(cmd_buffer, vs_shader, &nontrivial_divisors);
if (!prolog) {
cmd_buffer->record_result = VK_ERROR_OUT_OF_HOST_MEMORY;

6
src/amd/vulkan/radv_debug.c
View File

@ -488,17 +488,17 @@ radv_dump_vertex_descriptors(struct radv_graphics_pipeline *pipeline, FILE *f)
}
}
static struct radv_shader_prolog *
static struct radv_shader_part *
radv_get_saved_vs_prolog(struct radv_device *device)
{
uint64_t *ptr = (uint64_t *)device->trace_id_ptr;
return *(struct radv_shader_prolog **)(ptr + 4);
return *(struct radv_shader_part **)(ptr + 4);
}
static void
radv_dump_vs_prolog(struct radv_pipeline *pipeline, FILE *f)
{
struct radv_shader_prolog *vs_prolog = radv_get_saved_vs_prolog(pipeline->device);
struct radv_shader_part *vs_prolog = radv_get_saved_vs_prolog(pipeline->device);
struct radv_shader *vs_shader = radv_get_shader(pipeline, MESA_SHADER_VERTEX);
if (!vs_prolog || !vs_shader || !vs_shader->info.vs.has_prolog)

8
src/amd/vulkan/radv_device.c
View File

@ -2867,7 +2867,7 @@ radv_device_init_vs_prologs(struct radv_device *device)
key.num_attributes = num_attributes;
struct radv_shader_prolog *prolog = radv_create_vs_prolog(device, &key);
struct radv_shader_part *prolog = radv_create_vs_prolog(device, &key);
if (!prolog)
return vk_error(device->physical_device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@ -2889,16 +2889,16 @@ radv_device_finish_vs_prologs(struct radv_device *device)
hash_table_foreach(device->vs_prologs, entry)
{
free((void *)entry->key);
radv_prolog_destroy(device, entry->data);
radv_shader_part_destroy(device, entry->data);
}
_mesa_hash_table_destroy(device->vs_prologs, NULL);
}
for (unsigned i = 0; i < ARRAY_SIZE(device->simple_vs_prologs); i++)
radv_prolog_destroy(device, device->simple_vs_prologs[i]);
radv_shader_part_destroy(device, device->simple_vs_prologs[i]);
for (unsigned i = 0; i < ARRAY_SIZE(device->instance_rate_vs_prologs); i++)
radv_prolog_destroy(device, device->instance_rate_vs_prologs[i]);
radv_shader_part_destroy(device, device->instance_rate_vs_prologs[i]);
}
VkResult

6
src/amd/vulkan/radv_private.h
View File

@ -899,8 +899,8 @@ struct radv_device {
/* Prime blit sdma queue */
struct radv_queue *private_sdma_queue;
struct radv_shader_prolog *simple_vs_prologs[MAX_VERTEX_ATTRIBS];
struct radv_shader_prolog *instance_rate_vs_prologs[816];
struct radv_shader_part *simple_vs_prologs[MAX_VERTEX_ATTRIBS];
struct radv_shader_part *instance_rate_vs_prologs[816];
simple_mtx_t trace_mtx;
@ -1505,7 +1505,7 @@ struct radv_cmd_state {
uint32_t rt_stack_size;
struct radv_shader_prolog *emitted_vs_prolog;
struct radv_shader_part *emitted_vs_prolog;
uint32_t *emitted_vs_prolog_key;
uint32_t emitted_vs_prolog_key_hash;
uint32_t vbo_misaligned_mask;

42
src/amd/vulkan/radv_shader.c
View File

@ -2220,22 +2220,22 @@ radv_trap_handler_shader_destroy(struct radv_device *device, struct radv_trap_ha
free(trap);
}
static struct radv_shader_prolog *
upload_vs_prolog(struct radv_device *device, struct radv_prolog_binary *bin, unsigned wave_size)
static struct radv_shader_part *
upload_shader_part(struct radv_device *device, struct radv_shader_part_binary *bin, unsigned wave_size)
{
uint32_t code_size = radv_get_shader_binary_size(bin->code_size);
struct radv_shader_prolog *prolog = malloc(sizeof(struct radv_shader_prolog));
if (!prolog)
struct radv_shader_part *shader_part = malloc(sizeof(struct radv_shader_part));
if (!shader_part)
return NULL;
prolog->alloc = radv_alloc_shader_memory(device, code_size, NULL);
if (!prolog->alloc) {
free(prolog);
shader_part->alloc = radv_alloc_shader_memory(device, code_size, NULL);
if (!shader_part->alloc) {
free(shader_part);
return NULL;
}
prolog->bo = prolog->alloc->arena->bo;
char *dest_ptr = prolog->alloc->arena->ptr + prolog->alloc->offset;
shader_part->bo = shader_part->alloc->arena->bo;
char *dest_ptr = shader_part->alloc->arena->ptr + shader_part->alloc->offset;
memcpy(dest_ptr, bin->data, bin->code_size);
@ -2244,15 +2244,15 @@ upload_vs_prolog(struct radv_device *device, struct radv_prolog_binary *bin, uns
for (unsigned i = 0; i < DEBUGGER_NUM_MARKERS; i++)
ptr32[i] = DEBUGGER_END_OF_CODE_MARKER;
prolog->rsrc1 = S_00B848_VGPRS((bin->num_vgprs - 1) / (wave_size == 32 ? 8 : 4)) |
shader_part->rsrc1 = S_00B848_VGPRS((bin->num_vgprs - 1) / (wave_size == 32 ? 8 : 4)) |
S_00B228_SGPRS((bin->num_sgprs - 1) / 8);
prolog->num_preserved_sgprs = bin->num_preserved_sgprs;
prolog->disasm_string = NULL;
shader_part->num_preserved_sgprs = bin->num_preserved_sgprs;
shader_part->disasm_string = NULL;
return prolog;
return shader_part;
}
struct radv_shader_prolog *
struct radv_shader_part *
radv_create_vs_prolog(struct radv_device *device, const struct radv_vs_prolog_key *key)
{
struct radv_shader_args args = {0};
@ -2289,7 +2289,7 @@ radv_create_vs_prolog(struct radv_device *device, const struct radv_vs_prolog_ke
ac_init_llvm_once();
#endif
struct radv_prolog_binary *binary = NULL;
struct radv_shader_part_binary *binary = NULL;
struct aco_shader_info ac_info;
struct aco_vs_prolog_key ac_key;
struct aco_compiler_options ac_opts;
@ -2297,7 +2297,7 @@ radv_create_vs_prolog(struct radv_device *device, const struct radv_vs_prolog_ke
radv_aco_convert_opts(&ac_opts, &options);
radv_aco_convert_vs_prolog_key(&ac_key, key);
aco_compile_vs_prolog(&ac_opts, &ac_info, &ac_key, &args, &binary);
struct radv_shader_prolog *prolog = upload_vs_prolog(device, binary, info.wave_size);
struct radv_shader_part *prolog = upload_shader_part(device, binary, info.wave_size);
if (prolog) {
prolog->nontrivial_divisors = key->state->nontrivial_divisors;
prolog->disasm_string =
@ -2329,14 +2329,14 @@ radv_shader_destroy(struct radv_device *device, struct radv_shader *shader)
}
void
radv_prolog_destroy(struct radv_device *device, struct radv_shader_prolog *prolog)
radv_shader_part_destroy(struct radv_device *device, struct radv_shader_part *shader_part)
{
if (!prolog)
if (!shader_part)
return;
radv_free_shader_memory(device, prolog->alloc);
free(prolog->disasm_string);
free(prolog);
radv_free_shader_memory(device, shader_part->alloc);
free(shader_part->disasm_string);
free(shader_part);
}
uint64_t

10
src/amd/vulkan/radv_shader.h
View File

@ -441,7 +441,7 @@ struct radv_shader_binary_rtld {
uint8_t data[0];
};
struct radv_prolog_binary {
struct radv_shader_part_binary {
uint8_t num_sgprs;
uint8_t num_vgprs;
uint8_t num_preserved_sgprs;
@ -497,7 +497,7 @@ struct radv_trap_handler_shader {
union radv_shader_arena_block *alloc;
};
struct radv_shader_prolog {
struct radv_shader_part {
struct radeon_winsys_bo *bo;
union radv_shader_arena_block *alloc;
uint32_t rsrc1;
@ -578,12 +578,12 @@ uint64_t radv_trap_handler_shader_get_va(const struct radv_trap_handler_shader *
void radv_trap_handler_shader_destroy(struct radv_device *device,
struct radv_trap_handler_shader *trap);
struct radv_shader_prolog *radv_create_vs_prolog(struct radv_device *device,
const struct radv_vs_prolog_key *key);
struct radv_shader_part *radv_create_vs_prolog(struct radv_device *device,
const struct radv_vs_prolog_key *key);
void radv_shader_destroy(struct radv_device *device, struct radv_shader *shader);
void radv_prolog_destroy(struct radv_device *device, struct radv_shader_prolog *prolog);
void radv_shader_part_destroy(struct radv_device *device, struct radv_shader_part *shader_part);
uint64_t radv_shader_get_va(const struct radv_shader *shader);
struct radv_shader *radv_find_shader(struct radv_device *device, uint64_t pc);