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

glsl: remove do_copy_propagation_elements() optimisation pass

Browse Source 
Since 13b859de do_copy_propagation_elements() has a flaw where
the time it takes to complete grows exponentially slowers as the number
of nested loops increases. It can also hurt rather than help verses
just letting NIR optimise the code. So if the NIR linker is enabled we
let it handle it instead.

shader-db results Iris (BDW):

total instructions in shared programs: 11177181 -> 11199739 (0.20%)
instructions in affected programs: 119424 -> 141982 (18.89%)
helped: 109
HURT: 65
total cycles in shared programs: 368946819 -> 372277173 (0.90%)
cycles in affected programs: 116539428 -> 119869782 (2.86%)

total spills in shared programs: 3983 -> 8785 (120.56%)
spills in affected programs: 2072 -> 6874 (231.76%)
helped: 0
HURT: 6

total fills in shared programs: 2016 -> 6068 (200.99%)
fills in affected programs: 230 -> 4282 (1761.74%)
helped: 0
HURT: 6

LOST:   85
GAINED: 77

freedreno results:

total instructions in shared programs: 11011122 -> 11011620 (<.01%)
instructions in affected programs: 939829 -> 940327 (0.05%)
total full in shared programs: 762725 -> 762674 (<.01%)
full in affected programs: 1096 -> 1045 (-4.65%)
total constlen in shared programs: 1772092 -> 1771596 (-0.03%)
constlen in affected programs: 2780 -> 2284 (-17.84%)
total stp in shared programs: 4040 -> 4058 (0.45%)
stp in affected programs: 3656 -> 3674 (0.49%)
total ldp in shared programs: 2160 -> 2178 (0.83%)
ldp in affected programs: 1748 -> 1766 (1.03%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_high_off/13.shader_test CL: 1231 -> 1234 (0.24%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_normal_off/13.shader_test CL: 1231 -> 1234 (0.24%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_high_off/15.shader_test CL: 453 -> 456 (0.66%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_normal_off/15.shader_test CL: 453 -> 456 (0.66%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_high_off/17.shader_test CL: 144 -> 147 (2.08%)
stp HURT:   shaders/robclark-shaders/gfxbench5/gl_5_normal_off/17.shader_test CL: 144 -> 147 (2.08%)

however, those stp counts are misleading -- gfxbench gl-5-normal actually
gets its scratch (ldp/stp) stored as 16 bits instead of 32 thanks to
better NIR copy prop, and the result is 2.64398% +/- 0.0991923% perf
improvement!

i915 results:

total instructions in shared programs: 510528 -> 510489 (<.01%)
instructions in affected programs: 3303 -> 3264 (-1.18%)
total tex_indirect in shared programs: 16708 -> 16717 (0.05%)
tex_indirect in affected programs: 134 -> 143 (6.72%)
total temps in shared programs: 30181 -> 30169 (-0.04%)
temps in affected programs: 1268 -> 1256 (-0.95%)
LOST:   0
GAINED: 1

i915 highlights:
instructions HURT:   shaders/closed/steam/legend-of-grimrock/47.shader_test FS: 141 -> 144 (2.13%)
instructions HURT:   shaders/closed/steam/steamworld-dig/22.shader_test FS: 84 -> 108 (28.57%)
temps HURT:   shaders/closed/steam/left-4-dead-2/medium/3682.shader_test FS: 7 -> 13 (85.71%)

r300 results:

total instructions in shared programs: 1340439 -> 1340845 (0.03%)
instructions in affected programs: 32354 -> 32760 (1.25%)
total temps in shared programs: 179394 -> 179329 (-0.04%)
temps in affected programs: 1505 -> 1440 (-4.32%)
total consts in shared programs: 1177742 -> 1177885 (0.01%)
consts in affected programs: 1107 -> 1250 (12.92%)
total lits in shared programs: 24992 -> 25019 (0.11%)
lits in affected programs: 138 -> 165 (19.57%)
instructions HURT:   shaders/closed/steam/legend-of-grimrock/26.shader_test FS: 47 -> 52 (10.64%)
instructions HURT:   shaders/closed/steam/sanctum-2/6072.shader_test FS: 43 -> 48 (11.63%)
instructions HURT:   shaders/closed/steam/champions-of-regnum/2378.shader_test VS: 35 -> 40 (14.29%)

Reviewed-by: Emma Anholt <emma@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13288>
This commit is contained in:
Timothy Arceri
2022-06-08 11:30:58 +10:00
committed by Marge Bot
parent 106019a5d8
commit d75a36a9ee
8 changed files with 11 additions and 758 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/compiler/glsl/glsl_parser_extras.cpp
View File

@@ -2388,7 +2388,6 @@ do_common_optimization(exec_list *ir, bool linked,
OPT(propagate_invariance, ir);
OPT(do_if_simplification, ir);
OPT(opt_flatten_nested_if_blocks, ir);
OPT(do_copy_propagation_elements, ir);
if (options->OptimizeForAOS && !linked)
OPT(opt_flip_matrices, ir);

1
src/compiler/glsl/ir_optimization.h
View File

@@ -49,7 +49,6 @@ bool do_algebraic(exec_list *instructions, bool native_integers,
bool do_constant_folding(exec_list *instructions);
bool do_constant_variable(exec_list *instructions);
bool do_constant_variable_unlinked(exec_list *instructions);
bool do_copy_propagation_elements(exec_list *instructions);
bool do_constant_propagation(exec_list *instructions);
bool do_dead_code(exec_list *instructions);
bool do_dead_code_local(exec_list *instructions);

1
src/compiler/glsl/meson.build
View File

@@ -217,7 +217,6 @@ files_libglsl = files(
'opt_constant_folding.cpp',
'opt_constant_propagation.cpp',
'opt_constant_variable.cpp',
'opt_copy_propagation_elements.cpp',
'opt_dead_builtin_variables.cpp',
'opt_dead_code.cpp',
'opt_dead_code_local.cpp',

742
src/compiler/glsl/opt_copy_propagation_elements.cpp
View File

@@ -1,742 +0,0 @@
/*
* Copyright © 2010 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
/**
* \file opt_copy_propagation_elements.cpp
*
* Replaces usage of recently-copied components of variables with the
* previous copy of the variable.
*
* This should reduce the number of MOV instructions in the generated
* programs and help triggering other optimizations that live in GLSL
* level.
*/
#include "ir.h"
#include "ir_rvalue_visitor.h"
#include "ir_basic_block.h"
#include "ir_optimization.h"
#include "compiler/glsl_types.h"
#include "util/hash_table.h"
#include "util/set.h"
static bool debug = false;
namespace {
class acp_entry
{
public:
DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(acp_entry)
/* If set, rhs_full indicates that this ACP entry represents a
* whole-variable copy. The rhs_element[] array will still be filled,
* to allow the swizzling from its components in case the variable
* was a vector (and to simplify some of the erase() and write_vector()
* logic).
*/
ir_variable *rhs_full;
ir_variable *rhs_element[4];
unsigned rhs_channel[4];
/* Set of variables that use the variable associated with this acp_entry as
* RHS. This has the "reverse references" of rhs_full/rhs_element. It is
* used to speed up invalidating those references when the acp_entry
* changes.
*/
set *dsts;
};
class copy_propagation_state {
public:
DECLARE_RZALLOC_CXX_OPERATORS(copy_propagation_state);
static
copy_propagation_state* create(void *mem_ctx)
{
return new (mem_ctx) copy_propagation_state(NULL);
}
copy_propagation_state* clone()
{
return new (ralloc_parent(this)) copy_propagation_state(this);
}
void erase_all()
{
/* Individual elements were allocated from a linear allocator, so will
* be destroyed when the state is destroyed.
*/
_mesa_hash_table_clear(acp, NULL);
fallback = NULL;
}
void erase(ir_variable *var, unsigned write_mask)
{
acp_entry *entry = pull_acp(var);
entry->rhs_full = NULL;
for (int i = 0; i < 4; i++) {
if (!entry->rhs_element[i])
continue;
if ((write_mask & (1 << i)) == 0)
continue;
ir_variable *to_remove = entry->rhs_element[i];
entry->rhs_element[i] = NULL;
remove_unused_var_from_dsts(entry, var, to_remove);
}
/* TODO: Check write mask, and possibly not clear everything. */
/* For any usage of our variable on the RHS, clear it out. */
set_foreach(entry->dsts, set_entry) {
ir_variable *dst_var = (ir_variable *)set_entry->key;
acp_entry *dst_entry = pull_acp(dst_var);
for (int i = 0; i < 4; i++) {
if (dst_entry->rhs_element[i] == var)
dst_entry->rhs_element[i] = NULL;
}
if (dst_entry->rhs_full == var)
dst_entry->rhs_full = NULL;
_mesa_set_remove(entry->dsts, set_entry);
}
}
acp_entry *read(ir_variable *var)
{
for (copy_propagation_state *s = this; s != NULL; s = s->fallback) {
hash_entry *ht_entry = _mesa_hash_table_search(s->acp, var);
if (ht_entry)
return (acp_entry *) ht_entry->data;
}
return NULL;
}
void write_elements(ir_variable *lhs, ir_variable *rhs, unsigned write_mask, int swizzle[4])
{
acp_entry *lhs_entry = pull_acp(lhs);
lhs_entry->rhs_full = NULL;
for (int i = 0; i < 4; i++) {
if ((write_mask & (1 << i)) == 0)
continue;
ir_variable *to_remove = lhs_entry->rhs_element[i];
lhs_entry->rhs_element[i] = rhs;
lhs_entry->rhs_channel[i] = swizzle[i];
remove_unused_var_from_dsts(lhs_entry, lhs, to_remove);
}
acp_entry *rhs_entry = pull_acp(rhs);
_mesa_set_add(rhs_entry->dsts, lhs);
}
void write_full(ir_variable *lhs, ir_variable *rhs)
{
acp_entry *lhs_entry = pull_acp(lhs);
if (lhs_entry->rhs_full == rhs)
return;
if (lhs_entry->rhs_full) {
remove_from_dsts(lhs_entry->rhs_full, lhs);
} else if (lhs->type->is_vector()) {
for (int i = 0; i < 4; i++) {
if (lhs_entry->rhs_element[i])
remove_from_dsts(lhs_entry->rhs_element[i], lhs);
}
}
lhs_entry->rhs_full = rhs;
acp_entry *rhs_entry = pull_acp(rhs);
_mesa_set_add(rhs_entry->dsts, lhs);
if (lhs->type->is_vector()) {
for (int i = 0; i < 4; i++) {
lhs_entry->rhs_element[i] = rhs;
lhs_entry->rhs_channel[i] = i;
}
}
}
void remove_unused_var_from_dsts(acp_entry *lhs_entry, ir_variable *lhs, ir_variable *var)
{
if (!var)
return;
/* If lhs still uses var, don't remove anything. */
for (int j = 0; j < 4; j++) {
if (lhs_entry->rhs_element[j] == var)
return;
}
acp_entry *element = pull_acp(var);
assert(element);
_mesa_set_remove_key(element->dsts, lhs);
}
private:
explicit copy_propagation_state(copy_propagation_state *fallback)
{
this->fallback = fallback;
/* Use 'this' as context for the table, no explicit destruction
* needed later.
*/
acp = _mesa_pointer_hash_table_create(this);
lin_ctx = linear_alloc_parent(this, 0);
}
acp_entry *pull_acp(ir_variable *var)
{
hash_entry *ht_entry = _mesa_hash_table_search(acp, var);
if (ht_entry)
return (acp_entry *) ht_entry->data;
/* If not found, create one and copy data from fallback if available. */
acp_entry *entry = new(lin_ctx) acp_entry();
_mesa_hash_table_insert(acp, var, entry);
bool found = false;
for (copy_propagation_state *s = fallback; s != NULL; s = s->fallback) {
hash_entry *fallback_ht_entry = _mesa_hash_table_search(s->acp, var);
if (fallback_ht_entry) {
acp_entry *fallback_entry = (acp_entry *) fallback_ht_entry->data;
*entry = *fallback_entry;
entry->dsts = _mesa_set_clone(fallback_entry->dsts, this);
found = true;
break;
}
}
if (!found) {
entry->dsts = _mesa_pointer_set_create(this);
}
return entry;
}
void
remove_from_dsts(ir_variable *var, ir_variable *to_remove)
{
acp_entry *entry = pull_acp(var);
assert(entry);
_mesa_set_remove_key(entry->dsts, to_remove);
}
/** Available Copy to Propagate table, from variable to the entry
* containing the current sources that can be used. */
hash_table *acp;
/** When a state is cloned, entries are copied on demand from fallback. */
copy_propagation_state *fallback;
void *lin_ctx;
};
class kill_entry : public exec_node
{
public:
/* override operator new from exec_node */
DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(kill_entry)
kill_entry(ir_variable *var, int write_mask)
{
this->var = var;
this->write_mask = write_mask;
}
ir_variable *var;
unsigned int write_mask;
};
class ir_copy_propagation_elements_visitor : public ir_rvalue_visitor {
public:
ir_copy_propagation_elements_visitor()
{
this->progress = false;
this->killed_all = false;
this->mem_ctx = ralloc_context(NULL);
this->lin_ctx = linear_alloc_parent(this->mem_ctx, 0);
this->shader_mem_ctx = NULL;
this->kills = new(mem_ctx) exec_list;
this->state = copy_propagation_state::create(mem_ctx);
}
~ir_copy_propagation_elements_visitor()
{
ralloc_free(mem_ctx);
}
virtual ir_visitor_status visit(ir_dereference_variable *);
void handle_loop(ir_loop *, bool keep_acp);
virtual ir_visitor_status visit_enter(class ir_loop *);
virtual ir_visitor_status visit_enter(class ir_function_signature *);
virtual ir_visitor_status visit_leave(class ir_assignment *);
virtual ir_visitor_status visit_enter(class ir_call *);
virtual ir_visitor_status visit_enter(class ir_if *);
virtual ir_visitor_status visit_leave(class ir_swizzle *);
void handle_rvalue(ir_rvalue **rvalue);
void add_copy(ir_assignment *ir);
void kill(kill_entry *k);
void handle_if_block(exec_list *instructions, exec_list *kills, bool *killed_all);
copy_propagation_state *state;
/**
* List of kill_entry: The variables whose values were killed in this
* block.
*/
exec_list *kills;
bool progress;
bool killed_all;
/* Context for our local data structures. */
void *mem_ctx;
void *lin_ctx;
/* Context for allocating new shader nodes. */
void *shader_mem_ctx;
};
} /* unnamed namespace */
ir_visitor_status
ir_copy_propagation_elements_visitor::visit(ir_dereference_variable *ir)
{
if (this->in_assignee)
return visit_continue;
const acp_entry *entry = state->read(ir->var);
if (entry && entry->rhs_full) {
ir->var = (ir_variable *) entry->rhs_full;
progress = true;
}
return visit_continue;
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_enter(ir_function_signature *ir)
{
/* Treat entry into a function signature as a completely separate
* block. Any instructions at global scope will be shuffled into
* main() at link time, so they're irrelevant to us.
*/
exec_list *orig_kills = this->kills;
bool orig_killed_all = this->killed_all;
this->kills = new(mem_ctx) exec_list;
this->killed_all = false;
copy_propagation_state *orig_state = state;
this->state = copy_propagation_state::create(mem_ctx);
visit_list_elements(this, &ir->body);
delete this->state;
this->state = orig_state;
ralloc_free(this->kills);
this->kills = orig_kills;
this->killed_all = orig_killed_all;
return visit_continue_with_parent;
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_leave(ir_assignment *ir)
{
ir_dereference_variable *lhs = ir->lhs->as_dereference_variable();
ir_variable *var = ir->lhs->variable_referenced();
kill_entry *k;
if (lhs && var->type->is_vector())
k = new(this->lin_ctx) kill_entry(var, ir->write_mask);
else
k = new(this->lin_ctx) kill_entry(var, ~0);
kill(k);
add_copy(ir);
return visit_continue;
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_leave(ir_swizzle *)
{
/* Don't visit the values of swizzles since they are handled while
* visiting the swizzle itself.
*/
return visit_continue;
}
/**
* Replaces dereferences of ACP RHS variables with ACP LHS variables.
*
* This is where the actual copy propagation occurs. Note that the
* rewriting of ir_dereference means that the ir_dereference instance
* must not be shared by multiple IR operations!
*/
void
ir_copy_propagation_elements_visitor::handle_rvalue(ir_rvalue **ir)
{
int swizzle_chan[4];
ir_dereference_variable *deref_var;
ir_variable *source[4] = {NULL, NULL, NULL, NULL};
int source_chan[4] = {0, 0, 0, 0};
int chans;
bool noop_swizzle = true;
if (!*ir)
return;
ir_swizzle *swizzle = (*ir)->as_swizzle();
if (swizzle) {
deref_var = swizzle->val->as_dereference_variable();
if (!deref_var)
return;
swizzle_chan[0] = swizzle->mask.x;
swizzle_chan[1] = swizzle->mask.y;
swizzle_chan[2] = swizzle->mask.z;
swizzle_chan[3] = swizzle->mask.w;
chans = swizzle->type->vector_elements;
} else {
deref_var = (*ir)->as_dereference_variable();
if (!deref_var)
return;
swizzle_chan[0] = 0;
swizzle_chan[1] = 1;
swizzle_chan[2] = 2;
swizzle_chan[3] = 3;
chans = deref_var->type->vector_elements;
}
if (this->in_assignee)
return;
ir_variable *var = deref_var->var;
/* Try to find ACP entries covering swizzle_chan[], hoping they're
* the same source variable.
*/
const acp_entry *entry = state->read(var);
if (entry) {
for (int c = 0; c < chans; c++) {
unsigned index = swizzle_chan[c];
ir_variable *src = entry->rhs_element[index];
if (!src)
continue;
source[c] = src;
source_chan[c] = entry->rhs_channel[index];
if (source_chan[c] != swizzle_chan[c])
noop_swizzle = false;
}
}
/* Make sure all channels are copying from the same source variable. */
if (!source[0])
return;
for (int c = 1; c < chans; c++) {
if (source[c] != source[0])
return;
}
if (!shader_mem_ctx)
shader_mem_ctx = ralloc_parent(deref_var);
/* Don't pointlessly replace the rvalue with itself (or a noop swizzle
* of itself, which would just be deleted by opt_noop_swizzle).
*/
if (source[0] == var && noop_swizzle)
return;
if (debug) {
printf("Copy propagation from:\n");
(*ir)->print();
}
deref_var = new(shader_mem_ctx) ir_dereference_variable(source[0]);
*ir = new(shader_mem_ctx) ir_swizzle(deref_var,
source_chan[0],
source_chan[1],
source_chan[2],
source_chan[3],
chans);
progress = true;
if (debug) {
printf("to:\n");
(*ir)->print();
printf("\n");
}
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_enter(ir_call *ir)
{
/* Do copy propagation on call parameters, but skip any out params */
foreach_two_lists(formal_node, &ir->callee->parameters,
actual_node, &ir->actual_parameters) {
ir_variable *sig_param = (ir_variable *) formal_node;
ir_rvalue *ir = (ir_rvalue *) actual_node;
if (sig_param->data.mode != ir_var_function_out
&& sig_param->data.mode != ir_var_function_inout) {
ir->accept(this);
}
}
if (!ir->callee->is_intrinsic()) {
state->erase_all();
this->killed_all = true;
} else {
if (ir->return_deref) {
kill(new(this->lin_ctx) kill_entry(ir->return_deref->var, ~0));
}
foreach_two_lists(formal_node, &ir->callee->parameters,
actual_node, &ir->actual_parameters) {
ir_variable *sig_param = (ir_variable *) formal_node;
if (sig_param->data.mode == ir_var_function_out ||
sig_param->data.mode == ir_var_function_inout) {
ir_rvalue *ir = (ir_rvalue *) actual_node;
ir_variable *var = ir->variable_referenced();
kill(new(this->lin_ctx) kill_entry(var, ~0));
}
}
}
return visit_continue_with_parent;
}
void
ir_copy_propagation_elements_visitor::handle_if_block(exec_list *instructions, exec_list *kills, bool *killed_all)
{
exec_list *orig_kills = this->kills;
bool orig_killed_all = this->killed_all;
this->kills = kills;
this->killed_all = false;
/* Populate the initial acp with a copy of the original */
copy_propagation_state *orig_state = state;
this->state = orig_state->clone();
visit_list_elements(this, instructions);
delete this->state;
this->state = orig_state;
*killed_all = this->killed_all;
this->kills = orig_kills;
this->killed_all = orig_killed_all;
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_enter(ir_if *ir)
{
ir->condition->accept(this);
exec_list *new_kills = new(mem_ctx) exec_list;
bool then_killed_all = false;
bool else_killed_all = false;
handle_if_block(&ir->then_instructions, new_kills, &then_killed_all);
handle_if_block(&ir->else_instructions, new_kills, &else_killed_all);
if (then_killed_all || else_killed_all) {
state->erase_all();
killed_all = true;
} else {
foreach_in_list_safe(kill_entry, k, new_kills)
kill(k);
}
ralloc_free(new_kills);
/* handle_if_block() already descended into the children. */
return visit_continue_with_parent;
}
void
ir_copy_propagation_elements_visitor::handle_loop(ir_loop *ir, bool keep_acp)
{
exec_list *orig_kills = this->kills;
bool orig_killed_all = this->killed_all;
this->kills = new(mem_ctx) exec_list;
this->killed_all = false;
copy_propagation_state *orig_state = state;
if (keep_acp) {
/* Populate the initial acp with a copy of the original */
this->state = orig_state->clone();
} else {
this->state = copy_propagation_state::create(mem_ctx);
}
visit_list_elements(this, &ir->body_instructions);
delete this->state;
this->state = orig_state;
if (this->killed_all)
this->state->erase_all();
exec_list *new_kills = this->kills;
this->kills = orig_kills;
this->killed_all = this->killed_all || orig_killed_all;
foreach_in_list_safe(kill_entry, k, new_kills) {
kill(k);
}
ralloc_free(new_kills);
}
ir_visitor_status
ir_copy_propagation_elements_visitor::visit_enter(ir_loop *ir)
{
handle_loop(ir, false);
handle_loop(ir, true);
/* already descended into the children. */
return visit_continue_with_parent;
}
/* Remove any entries currently in the ACP for this kill. */
void
ir_copy_propagation_elements_visitor::kill(kill_entry *k)
{
state->erase(k->var, k->write_mask);
/* If we were on a list, remove ourselves before inserting */
if (k->next)
k->remove();
this->kills->push_tail(k);
}
/**
* Adds directly-copied channels between vector variables to the available
* copy propagation list.
*/
void
ir_copy_propagation_elements_visitor::add_copy(ir_assignment *ir)
{
{
ir_variable *lhs_var = ir->whole_variable_written();
ir_dereference_variable *rhs = ir->rhs->as_dereference_variable();
if (lhs_var != NULL && rhs && rhs->var != NULL && lhs_var != rhs->var) {
if (lhs_var->data.mode == ir_var_shader_storage ||
lhs_var->data.mode == ir_var_shader_shared ||
rhs->var->data.mode == ir_var_shader_storage ||
rhs->var->data.mode == ir_var_shader_shared ||
lhs_var->data.precise != rhs->var->data.precise) {
return;
}
state->write_full(lhs_var, rhs->var);
return;
}
}
int orig_swizzle[4] = {0, 1, 2, 3};
int swizzle[4];
ir_dereference_variable *lhs = ir->lhs->as_dereference_variable();
if (!lhs || !(lhs->type->is_scalar() || lhs->type->is_vector()))
return;
if (lhs->var->data.mode == ir_var_shader_storage ||
lhs->var->data.mode == ir_var_shader_shared)
return;
ir_dereference_variable *rhs = ir->rhs->as_dereference_variable();
if (!rhs) {
ir_swizzle *swiz = ir->rhs->as_swizzle();
if (!swiz)
return;
rhs = swiz->val->as_dereference_variable();
if (!rhs)
return;
orig_swizzle[0] = swiz->mask.x;
orig_swizzle[1] = swiz->mask.y;
orig_swizzle[2] = swiz->mask.z;
orig_swizzle[3] = swiz->mask.w;
}
if (rhs->var->data.mode == ir_var_shader_storage ||
rhs->var->data.mode == ir_var_shader_shared)
return;
/* Move the swizzle channels out to the positions they match in the
* destination. We don't want to have to rewrite the swizzle[]
* array every time we clear a bit of the write_mask.
*/
int j = 0;
for (int i = 0; i < 4; i++) {
if (ir->write_mask & (1 << i))
swizzle[i] = orig_swizzle[j++];
}
int write_mask = ir->write_mask;
if (lhs->var == rhs->var) {
/* If this is a copy from the variable to itself, then we need
* to be sure not to include the updated channels from this
* instruction in the set of new source channels to be
* copy-propagated from.
*/
for (int i = 0; i < 4; i++) {
if (ir->write_mask & (1 << orig_swizzle[i]))
write_mask &= ~(1 << i);
}
}
if (lhs->var->data.precise != rhs->var->data.precise)
return;
state->write_elements(lhs->var, rhs->var, write_mask, swizzle);
}
bool
do_copy_propagation_elements(exec_list *instructions)
{
ir_copy_propagation_elements_visitor v;
visit_list_elements(&v, instructions);
return v.progress;
}

2
src/compiler/glsl/test_optpass.cpp
View File

@@ -72,8 +72,6 @@ do_optimization(struct exec_list *ir, const char *optimization,
return do_constant_variable(ir);
} else if (strcmp(optimization, "do_constant_variable_unlinked") == 0) {
return do_constant_variable_unlinked(ir);
} else if (strcmp(optimization, "do_copy_propagation_elements") == 0) {
return do_copy_propagation_elements(ir);
} else if (strcmp(optimization, "do_constant_propagation") == 0) {
return do_constant_propagation(ir);
} else if (strcmp(optimization, "do_dead_code") == 0) {

6
src/freedreno/ci/traces-freedreno.yml
View File

@@ -254,14 +254,14 @@ traces:
text: missing 3/4 of rendered image
checksum: e7f01e62180b60aef8c67fc4977c90d1
freedreno-a530:
checksum: 70c57b3aea1f18baacb234ecc35bf425
checksum: 71f46ff29ab058f89c745ddede5cc907
freedreno-a630:
label: [skip]
text: |-
One of the material textures appears brighter on freedreno than
i965 in a way that is probably wrong.
zink-a630:
checksum: 474fe595707f0e4f3e3474a5a6300ca9
checksum: 227516d3818969c68a1864aa942119c2
gputest/pixmark-volplosion-v2.trace:
freedreno-a306:
@@ -513,7 +513,7 @@ traces:
label: [unsupported]
text: needs GL 4.6
freedreno-a630:
checksum: 2b96947d3eb3f623c4a387b2b7f80300
checksum: a2dbcd27c404a1bb0f7d60476d93d22c
zink-a630:
label: [crash]
text: |-

4
src/gallium/drivers/zink/ci/traces-zink.yml
View File

@@ -22,7 +22,7 @@ traces:
text: "https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/20319"
freedoom/freedoom-phase2-gl-high.trace:
gl-zink-anv-tgl:
checksum: fa674cb9aa2fd7f4d6329388478b5519
checksum: 288b762ac80ed76e18f848649a618be1
glxgears/glxgears-2-v2.trace:
gl-zink-anv-tgl:
checksum: f53ac20e17da91c0359c31f2fa3f401e
@@ -31,7 +31,7 @@ traces:
checksum: 433b69bea68cfe81914b857bbdc60ea5
gputest/pixmark-piano-v2.trace:
gl-zink-anv-tgl:
checksum: d0c04a9f711d639ff82c96f1972aca96
checksum: de1b16f8d3aca63e5903ccef47d82f2d
gputest/triangle-v2.trace:
gl-zink-anv-tgl:
checksum: 5f694874b15bcd7a3689b387c143590b

12
src/intel/ci/traces-iris.yml
View File

@@ -504,17 +504,17 @@ traces:
checksum: f11aa01f5ef3a563567e2a85998c418e
freedoom/freedoom-phase2-gl-high.trace:
gl-intel-apl:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
gl-intel-glx:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
gl-intel-amly:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
gl-intel-kbl:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
gl-intel-whl:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
gl-intel-cml:
checksum: 13860db550196b58c07c7a5493d4cbb1
checksum: b9951727c5c869d5ca510d83a557711b
unvanquished/unvanquished-lowest.trace:
gl-intel-apl:
checksum: 884096b6dd40e2f500d0837501287fac