panfrost: introduce LDST_ATOMIC property

[mesa.git] / src / panfrost / midgard / midgard_opt_dce.c

diff --git a/src/panfrost/midgard/midgard_opt_dce.c b/src/panfrost/midgard/midgard_opt_dce.c
index 6621c2fe2ddb0844ee4da4e23fee598f52e51d0d..da3f0b7b5f05a1ffefc276cfc5492a5993ad87a9 100644 (file)
--- a/src/panfrost/midgard/midgard_opt_dce.c
+++ b/src/panfrost/midgard/midgard_opt_dce.c
@@ -23,23 +23,145 @@
  */
 
 #include "compiler.h"
+#include "util/u_memory.h"
+#include "midgard_ops.h"
 
-/* Basic dead code elimination on the MIR itself */
+/* SIMD-aware dead code elimination. Perform liveness analysis step-by-step,
+ * removing dead components. If an instruction ends up with a zero mask, the
+ * instruction in total is dead and should be removed. */
+
+static bool
+can_cull_mask(compiler_context *ctx, midgard_instruction *ins)
+{
+        if (ins->dest >= ctx->temp_count)
+                return false;
+
+        if (ins->dest == ctx->blend_src1)
+                return false;
+
+        if (ins->type == TAG_LOAD_STORE_4)
+                if (load_store_opcode_props[ins->op].props & LDST_SPECIAL_MASK)
+                        return false;
+
+        return true;
+}
+
+static bool
+can_dce(midgard_instruction *ins)
+{
+        if (ins->mask)
+                return false;
+
+        if (ins->compact_branch)
+                return false;
+
+        if (ins->type == TAG_LOAD_STORE_4)
+                if (load_store_opcode_props[ins->op].props & LDST_SIDE_FX)
+                        return false;
+
+        if (ins->type == TAG_TEXTURE_4)
+                if (ins->op == TEXTURE_OP_BARRIER)
+                        return false;
+
+        return true;
+}
+
+static bool
+midgard_opt_dead_code_eliminate_block(compiler_context *ctx, midgard_block *block)
+{
+        bool progress = false;
+
+        uint16_t *live = mem_dup(block->base.live_out, ctx->temp_count * sizeof(uint16_t));
+
+        mir_foreach_instr_in_block_rev(block, ins) {
+                if (can_cull_mask(ctx, ins)) {
+                        unsigned type_size = nir_alu_type_get_type_size(ins->dest_type);
+                        unsigned round_size = type_size;
+                        unsigned oldmask = ins->mask;
+
+                        /* Make sure we're packable */
+                        if (type_size == 16 && ins->type == TAG_LOAD_STORE_4)
+                                round_size = 32;
+
+                        unsigned rounded = mir_round_bytemask_up(live[ins->dest], round_size);
+                        unsigned cmask = mir_from_bytemask(rounded, type_size);
+
+                        ins->mask &= cmask;
+                        progress |= (ins->mask != oldmask);
+                }
+
+                mir_liveness_ins_update(live, ins, ctx->temp_count);
+        }
+
+        mir_foreach_instr_in_block_safe(block, ins) {
+                if (can_dce(ins)) {
+                        mir_remove_instruction(ins);
+                        progress = true;
+                }
+        }
+
+        free(live);
+
+        return progress;
+}
+
+bool
+midgard_opt_dead_code_eliminate(compiler_context *ctx)
+{
+        /* We track liveness. In fact, it's ok if we assume more things are
+         * live than they actually are, that just reduces the effectiveness of
+         * this iterations lightly. And DCE has the effect of strictly reducing
+         * liveness, so we can run DCE across all blocks while only computing
+         * liveness at the beginning. */
+
+        mir_invalidate_liveness(ctx);
+        mir_compute_liveness(ctx);
+
+        bool progress = false;
+
+        mir_foreach_block(ctx, block) {
+                progress |= midgard_opt_dead_code_eliminate_block(ctx, (midgard_block *) block);
+        }
+
+        return progress;
+}
+
+/* Removes dead moves, that is, moves with a destination overwritten before
+ * being read. Normally handled implicitly as part of DCE, but this has to run
+ * after the out-of-SSA pass */
 
 bool
-midgard_opt_dead_code_eliminate(compiler_context *ctx, midgard_block *block)
+midgard_opt_dead_move_eliminate(compiler_context *ctx, midgard_block *block)
 {
         bool progress = false;
 
         mir_foreach_instr_in_block_safe(block, ins) {
                 if (ins->type != TAG_ALU_4) continue;
                 if (ins->compact_branch) continue;
+                if (!OP_IS_MOVE(ins->op)) continue;
+
+                /* Check if it's overwritten in this block before being read */
+                bool overwritten = false;
+
+                mir_foreach_instr_in_block_from(block, q, mir_next_op(ins)) {
+                        /* Check if used */
+                        if (mir_has_arg(q, ins->dest))
+                                break;
+
+                        /* Check if overwritten */
+                        if (q->dest == ins->dest) {
+                                /* Special case to vec4; component tracking is
+                                 * harder */
 
-                if (ins->ssa_args.dest >= SSA_FIXED_MINIMUM) continue;
-                if (mir_is_live_after(ctx, block, ins, ins->ssa_args.dest)) continue;
+                                overwritten = (q->mask == 0xF);
+                                break;
+                        }
+                }
 
-                mir_remove_instruction(ins);
-                progress = true;
+                if (overwritten) {
+                        mir_remove_instruction(ins);
+                        progress = true;
+                }
         }
 
         return progress;