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

pco: re-indexing debug option and additional vector and component tracking

Browse Source 
Signed-off-by: Simon Perretta <simon.perretta@imgtec.com>
Acked-by: Frank Binns <frank.binns@imgtec.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/32258>
This commit is contained in:
Simon Perretta
2024-11-13 22:58:16 +00:00
committed by Marge Bot
parent d55e98a32d
commit a89a9b65f8
10 changed files with 119 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
docs/envvars.rst
View File

@@ -1998,6 +1998,9 @@ PowerVR driver environment variables
``val_skip``
Skip IR validation.
``reindex``
Reindex IR at the end of each pass.
.. envvar:: PCO_SKIP_PASSES
A comma-separated list of passes to skip.

2
src/imagination/pco/pco.c
View File

@@ -160,7 +160,7 @@ pco_func *pco_func_create(pco_shader *shader,
rzalloc_array_size(func, sizeof(*func->params), num_params);
}
func->vec_comps = _mesa_hash_table_u64_create(func);
func->vec_infos = _mesa_hash_table_u64_create(func);
return func;
}

1
src/imagination/pco/pco_debug.c
View File

@@ -24,6 +24,7 @@
static const struct debug_named_value pco_debug_options[] = {
{ "val_skip", PCO_DEBUG_VAL_SKIP, "Skip IR validation." },
{ "reindex", PCO_DEBUG_REINDEX, "Reindex IR at the end of each pass." },
DEBUG_NAMED_VALUE_END,
};

61
src/imagination/pco/pco_index.c
View File

@@ -23,48 +23,62 @@
* \brief Indexes all shader child structures.
*
* \param[in,out] shader PCO shader.
* \param[in] skip_ssa Whether to skip SSA indexing.
* \return True if the pass made progress.
*/
bool pco_index(pco_shader *shader)
bool pco_index(pco_shader *shader, bool skip_ssa)
{
assert(!shader->is_grouped);
/* TODO */
if (shader->is_grouped)
return false;
shader->next_func = 0;
pco_foreach_func_in_shader (func, shader) {
unsigned *ssa_idx_map =
rzalloc_array_size(NULL, sizeof(*ssa_idx_map), func->next_ssa);
unsigned *ssa_idx_map = NULL;
if (!skip_ssa) {
ssa_idx_map =
rzalloc_array_size(NULL, sizeof(*ssa_idx_map), func->next_ssa);
}
func->index = shader->next_func++;
func->next_ssa = 0;
func->next_instr = 0;
func->next_block = 0;
struct hash_table_u64 *vec_comps = _mesa_hash_table_u64_create(func);
struct hash_table_u64 *vec_infos = NULL;
if (!skip_ssa) {
func->next_ssa = 0;
vec_infos = _mesa_hash_table_u64_create(func);
}
pco_foreach_block_in_func (block, func) {
block->index = func->next_block++;
pco_foreach_instr_in_block (instr, block) {
instr->index = func->next_instr++;
pco_foreach_instr_dest_ssa (pdest, instr) {
ssa_idx_map[pdest->val] = func->next_ssa++;
if (instr->op == PCO_OP_VEC) {
pco_instr **comps =
_mesa_hash_table_u64_search(func->vec_comps, pdest->val);
if (!skip_ssa) {
pco_foreach_instr_dest_ssa (pdest, instr) {
ssa_idx_map[pdest->val] = func->next_ssa++;
if (instr->op == PCO_OP_VEC) {
pco_vec_info *vec_info =
_mesa_hash_table_u64_search(func->vec_infos,
pdest->val);
ralloc_steal(vec_comps, comps);
ralloc_steal(vec_infos, vec_info);
_mesa_hash_table_u64_insert(vec_comps,
ssa_idx_map[pdest->val],
comps);
_mesa_hash_table_u64_insert(vec_infos,
ssa_idx_map[pdest->val],
vec_info);
}
pdest->val = ssa_idx_map[pdest->val];
}
pdest->val = ssa_idx_map[pdest->val];
}
}
}
pco_foreach_instr_in_func (instr, func) {
pco_foreach_instr_src_ssa (psrc, instr) {
psrc->val = ssa_idx_map[psrc->val];
if (!skip_ssa) {
pco_foreach_instr_in_func (instr, func) {
pco_foreach_instr_src_ssa (psrc, instr) {
psrc->val = ssa_idx_map[psrc->val];
}
}
}
@@ -72,10 +86,11 @@ bool pco_index(pco_shader *shader)
/* pco_foreach_if_in_func */
/* pco_foreach_loop_in_func */
_mesa_hash_table_u64_destroy(func->vec_comps);
func->vec_comps = vec_comps;
ralloc_free(ssa_idx_map);
if (!skip_ssa) {
_mesa_hash_table_u64_destroy(func->vec_infos);
func->vec_infos = vec_infos;
ralloc_free(ssa_idx_map);
}
}
return true;

14
src/imagination/pco/pco_internal.h
View File

@@ -50,6 +50,7 @@ void pco_setup_nir_options(const struct pvr_device_info *dev_info,
/* Debug. */
enum pco_debug {
PCO_DEBUG_VAL_SKIP = BITFIELD64_BIT(0),
PCO_DEBUG_REINDEX = BITFIELD64_BIT(1),
};
extern uint64_t pco_debug;
@@ -279,6 +280,15 @@ typedef struct _pco_loop {
unsigned index; /** Loop index. */
} pco_loop;
#define VEC_USER_MULTI ((void *)(~0ULL))
/** PCO vector information. */
typedef struct _pco_vec_info {
pco_instr *instr; /** Vector producer. */
pco_instr **comps; /** Array of vector components. */
pco_instr *vec_user; /** Vector user, or none, or multi. */
} pco_vec_info;
/** PCO function. */
typedef struct _pco_func {
struct list_head link; /** Link in pco_shader::funcs. */
@@ -295,7 +305,7 @@ typedef struct _pco_func {
unsigned num_params;
pco_ref *params;
struct hash_table_u64 *vec_comps;
struct hash_table_u64 *vec_infos;
unsigned next_ssa; /** Next SSA node index. */
unsigned next_instr; /** Next instruction index. */
@@ -1095,7 +1105,7 @@ bool pco_const_imms(pco_shader *shader);
bool pco_dce(pco_shader *shader);
bool pco_end(pco_shader *shader);
bool pco_group_instrs(pco_shader *shader);
bool pco_index(pco_shader *shader);
bool pco_index(pco_shader *shader, bool skip_ssa);
bool pco_nir_pfo(nir_shader *nir);
bool pco_nir_pvi(nir_shader *nir);
bool pco_opt(pco_shader *shader);

3
src/imagination/pco/pco_ir.c
View File

@@ -33,6 +33,9 @@ static inline bool pco_should_skip_pass(const char *pass)
UNUSED bool _; \
progress = true; \
\
if (PCO_DEBUG(REINDEX)) \
pco_index(shader, false); \
\
pco_validate_shader(shader, "after " #pass); \
\
if (pco_should_print_shader_pass(shader)) \

8
src/imagination/pco/pco_opt.c
View File

@@ -273,12 +273,8 @@ static inline bool fwd_prop(pco_shader *shader)
bool pco_opt(pco_shader *shader)
{
bool progress = false;
pco_index(shader);
progress |= back_prop(shader);
progress |= fwd_prop(shader);
return progress;
}
@@ -314,7 +310,6 @@ bool pco_dce(pco_shader *shader)
bool progress = false;
BITSET_WORD *ssa_used;
pco_index(shader);
pco_foreach_func_in_shader (func, shader) {
ssa_used = rzalloc_array_size(NULL,
sizeof(*ssa_used),
@@ -348,8 +343,5 @@ bool pco_dce(pco_shader *shader)
ralloc_free(ssa_used);
}
if (progress)
pco_index(shader);
return progress;
}

2
src/imagination/pco/pco_ra.c
View File

@@ -282,8 +282,6 @@ bool pco_ra(pco_shader *shader)
{
assert(!shader->is_grouped);
pco_index(shader);
unsigned hw_temps = rogue_get_temps(shader->ctx->dev_info);
/* TODO:
* unsigned opt_temps = rogue_get_optimal_temps(shader->ctx->dev_info);

3
src/imagination/pco/pco_schedule.c
View File

@@ -43,8 +43,5 @@ bool pco_schedule(pco_shader *shader)
}
}
if (progress)
pco_index(shader);
return progress;
}

85
src/imagination/pco/pco_trans_nir.c
View File

@@ -45,23 +45,27 @@ static pco_block *trans_cf_nodes(trans_ctx *tctx,
* \brief Splits a vector destination into scalar components.
*
* \param[in,out] tctx Translation context.
* \param[in] instr Instruction producing the vector destination.
* \param[in] dest Instruction destination.
*/
static void split_dest_comps(trans_ctx *tctx, pco_ref dest)
static void split_dest_comps(trans_ctx *tctx, pco_instr *instr, pco_ref dest)
{
unsigned chans = pco_ref_get_chans(dest);
assert(chans > 1);
pco_func *func = tctx->func;
pco_instr **comps =
rzalloc_array_size(func->vec_comps, sizeof(*comps), chans);
pco_vec_info *vec_info = rzalloc_size(func->vec_infos, sizeof(*vec_info));
vec_info->instr = instr;
vec_info->comps =
rzalloc_array_size(vec_info, sizeof(*vec_info->comps), chans);
for (unsigned u = 0; u < chans; ++u) {
pco_ref comp = pco_ref_new_ssa(func, pco_ref_get_bits(dest), 1);
comps[u] = pco_comp(&tctx->b, comp, dest, pco_ref_val16(u));
vec_info->comps[u] = pco_comp(&tctx->b, comp, dest, pco_ref_val16(u));
}
_mesa_hash_table_u64_insert(func->vec_comps, dest.val, comps);
_mesa_hash_table_u64_insert(func->vec_infos, dest.val, vec_info);
}
/**
@@ -144,25 +148,25 @@ pco_ref_nir_alu_src_t(const nir_alu_instr *alu, unsigned src, trans_ctx *tctx)
if (!swizzle0 && seq_comps && chans == nir_src_num_components(alu_src->src))
return ref;
pco_instr **comps =
_mesa_hash_table_u64_search(tctx->func->vec_comps, ref.val);
assert(comps);
pco_vec_info *vec_info =
_mesa_hash_table_u64_search(tctx->func->vec_infos, ref.val);
assert(vec_info);
/* One channel; just return its component. */
if (chans == 1)
return comps[swizzle0]->dest[0];
return vec_info->comps[swizzle0]->dest[0];
/* Multiple channels, either a partial vec and/or swizzling; we need to build
* a new vec for this.
*/
pco_ref vec_comps[NIR_MAX_VEC_COMPONENTS] = { 0 };
pco_ref comps[NIR_MAX_VEC_COMPONENTS] = { 0 };
for (unsigned u = 0; u < chans; ++u)
vec_comps[u] = comps[alu_src->swizzle[u]]->dest[0];
comps[u] = vec_info->comps[alu_src->swizzle[u]]->dest[0];
pco_ref vec = pco_ref_new_ssa(tctx->func, pco_ref_get_bits(ref), chans);
pco_vec(&tctx->b, vec, chans, vec_comps);
pco_instr *instr = pco_vec(&tctx->b, vec, chans, comps);
split_dest_comps(tctx, vec);
split_dest_comps(tctx, instr, vec);
return vec;
}
@@ -331,7 +335,7 @@ static pco_instr *trans_intr(trans_ctx *tctx, nir_intrinsic_instr *intr)
}
if (!pco_ref_is_scalar(dest))
split_dest_comps(tctx, dest);
split_dest_comps(tctx, instr, dest);
return instr;
}
@@ -432,7 +436,7 @@ static unsigned try_collate_vec_srcs(trans_ctx *tctx,
collated_src[num_srcs_collated++] = collated_ref;
s += chans - 1;
collated_vector |= true;
collated_vector = true;
}
return collated_vector ? num_srcs_collated : 0;
@@ -460,7 +464,23 @@ static pco_instr *pco_trans_nir_vec(trans_ctx *tctx,
if (!num_srcs_collated)
return pco_vec(&tctx->b, dest, num_srcs, src);
return pco_vec(&tctx->b, dest, num_srcs_collated, collated_src);
pco_instr *instr = pco_vec(&tctx->b, dest, num_srcs_collated, collated_src);
/* Record the collated vectors. */
for (unsigned s = 0; s < num_srcs_collated; ++s) {
if (pco_ref_is_scalar(collated_src[s]))
continue;
pco_vec_info *vec_info =
_mesa_hash_table_u64_search(tctx->func->vec_infos,
collated_src[s].val);
assert(vec_info);
/* Skip if there are multiple users. */
vec_info->vec_user = vec_info->vec_user ? VEC_USER_MULTI : instr;
}
return instr;
}
/**
@@ -525,7 +545,7 @@ static pco_instr *trans_alu(trans_ctx *tctx, nir_alu_instr *alu)
}
if (!pco_ref_is_scalar(dest))
split_dest_comps(tctx, dest);
split_dest_comps(tctx, instr, dest);
return instr;
}
@@ -540,20 +560,37 @@ static pco_instr *trans_alu(trans_ctx *tctx, nir_alu_instr *alu)
static pco_instr *trans_const(trans_ctx *tctx, nir_load_const_instr *nconst)
{
unsigned num_bits = nconst->def.bit_size;
unsigned comps = nconst->def.num_components;
unsigned chans = nconst->def.num_components;
/* TODO: support more bit sizes/components. */
assert(num_bits == 32);
assert(comps == 1);
uint64_t val = nir_const_value_as_uint(nconst->value[0], num_bits);
pco_ref dest = pco_ref_nir_def_t(&nconst->def, tctx);
pco_ref imm = pco_ref_imm(val, pco_bits(num_bits), pco_ref_get_dtype(dest));
pco_instr *instr = pco_movi32(&tctx->b, dest, imm);
if (pco_ref_is_scalar(dest)) {
assert(chans == 1);
if (!pco_ref_is_scalar(dest))
split_dest_comps(tctx, dest);
uint64_t val = nir_const_value_as_uint(nconst->value[0], num_bits);
pco_ref imm =
pco_ref_imm(val, pco_bits(num_bits), pco_ref_get_dtype(dest));
return pco_movi32(&tctx->b, dest, imm);
}
pco_ref comps[NIR_MAX_VEC_COMPONENTS] = { 0 };
for (unsigned c = 0; c < chans; ++c) {
comps[c] = pco_ref_new_ssa(tctx->func, pco_ref_get_bits(dest), 1);
uint64_t val = nir_const_value_as_uint(nconst->value[c], num_bits);
pco_ref imm =
pco_ref_imm(val, pco_bits(num_bits), pco_ref_get_dtype(dest));
pco_movi32(&tctx->b, comps[c], imm);
}
pco_instr *instr = pco_vec(&tctx->b, dest, chans, comps);
split_dest_comps(tctx, instr, dest);
return instr;
}