projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
aco: always set FI on GFX10
[mesa.git] / src / amd / compiler / aco_scheduler.cpp
diff --git a/src/amd/compiler/aco_scheduler.cpp b/src/amd/compiler/aco_scheduler.cpp
index 84b0fa10cad1a0143070f9b1f9fad289cccb92c4..cb22491bf64a1b5a2c58b553d591e26ec89c7cda 100644 (file)
--- a/src/amd/compiler/aco_scheduler.cpp
+++ b/src/amd/compiler/aco_scheduler.cpp
@@ -113,35 +113,6 @@ void move_element(T begin_it, size_t idx, size_t before) {
     }
 }
 
-static RegisterDemand getLiveChanges(aco_ptr<Instruction>& instr)
-{
-   RegisterDemand changes;
-   for (const Definition& def : instr->definitions) {
-      if (!def.isTemp() || def.isKill())
-         continue;
-      changes += def.getTemp();
-   }
-
-   for (const Operand& op : instr->operands) {
-      if (!op.isTemp() || !op.isFirstKill())
-         continue;
-      changes -= op.getTemp();
-   }
-
-   return changes;
-}
-
-static RegisterDemand getTempRegisters(aco_ptr<Instruction>& instr)
-{
-   RegisterDemand temp_registers;
-   for (const Definition& def : instr->definitions) {
-      if (!def.isTemp() || !def.isKill())
-         continue;
-      temp_registers += def.getTemp();
-   }
-   return temp_registers;
-}
-
 void MoveState::downwards_advance_helper()
 {
    source_idx--;
@@ -207,11 +178,11 @@ MoveResult MoveState::downwards_move(bool clause)
    int dest_insert_idx = clause ? insert_idx_clause : insert_idx;
    RegisterDemand register_pressure = clause ? total_demand_clause : total_demand;
 
-   const RegisterDemand candidate_diff = getLiveChanges(instr);
-   const RegisterDemand temp = getTempRegisters(instr);
+   const RegisterDemand candidate_diff = get_live_changes(instr);
+   const RegisterDemand temp = get_temp_registers(instr);
    if (RegisterDemand(register_pressure - candidate_diff).exceeds(max_registers))
       return move_fail_pressure;
-   const RegisterDemand temp2 = getTempRegisters(block->instructions[dest_insert_idx - 1]);
+   const RegisterDemand temp2 = get_temp_registers(block->instructions[dest_insert_idx - 1]);
    const RegisterDemand new_demand = register_demand[dest_insert_idx - 1] - temp2 + temp;
    if (new_demand.exceeds(max_registers))
       return move_fail_pressure;
@@ -302,11 +273,11 @@ MoveResult MoveState::upwards_move()
    }
 
    /* check if register pressure is low enough: the diff is negative if register pressure is decreased */
-   const RegisterDemand candidate_diff = getLiveChanges(instr);
-   const RegisterDemand temp = getTempRegisters(instr);
+   const RegisterDemand candidate_diff = get_live_changes(instr);
+   const RegisterDemand temp = get_temp_registers(instr);
    if (RegisterDemand(total_demand + candidate_diff).exceeds(max_registers))
       return move_fail_pressure;
-   const RegisterDemand temp2 = getTempRegisters(block->instructions[insert_idx - 1]);
+   const RegisterDemand temp2 = get_temp_registers(block->instructions[insert_idx - 1]);
    const RegisterDemand new_demand = register_demand[insert_idx - 1] - temp2 + candidate_diff + temp;
    if (new_demand.exceeds(max_registers))
       return move_fail_pressure;
@@ -367,40 +338,40 @@ bool can_reorder(Instruction* candidate)
    }
 }
 
-bool is_gs_or_done_sendmsg(Instruction *instr)
+bool is_gs_or_done_sendmsg(const Instruction *instr)
 {
    if (instr->opcode == aco_opcode::s_sendmsg) {
-      uint16_t imm = static_cast<SOPP_instruction*>(instr)->imm;
+      uint16_t imm = static_cast<const SOPP_instruction*>(instr)->imm;
       return (imm & sendmsg_id_mask) == _sendmsg_gs ||
              (imm & sendmsg_id_mask) == _sendmsg_gs_done;
    }
    return false;
 }
 
-bool is_done_sendmsg(Instruction *instr)
+bool is_done_sendmsg(const Instruction *instr)
 {
    if (instr->opcode == aco_opcode::s_sendmsg) {
-      uint16_t imm = static_cast<SOPP_instruction*>(instr)->imm;
+      uint16_t imm = static_cast<const SOPP_instruction*>(instr)->imm;
       return (imm & sendmsg_id_mask) == _sendmsg_gs_done;
    }
    return false;
 }
 
-barrier_interaction get_barrier_interaction(Instruction* instr)
+barrier_interaction get_barrier_interaction(const Instruction* instr)
 {
    switch (instr->format) {
    case Format::SMEM:
-      return static_cast<SMEM_instruction*>(instr)->barrier;
+      return static_cast<const SMEM_instruction*>(instr)->barrier;
    case Format::MUBUF:
-      return static_cast<MUBUF_instruction*>(instr)->barrier;
+      return static_cast<const MUBUF_instruction*>(instr)->barrier;
    case Format::MIMG:
-      return static_cast<MIMG_instruction*>(instr)->barrier;
+      return static_cast<const MIMG_instruction*>(instr)->barrier;
    case Format::MTBUF:
-      return static_cast<MTBUF_instruction*>(instr)->barrier;
+      return static_cast<const MTBUF_instruction*>(instr)->barrier;
    case Format::FLAT:
    case Format::GLOBAL:
    case Format::SCRATCH:
-      return static_cast<FLAT_instruction*>(instr)->barrier;
+      return static_cast<const FLAT_instruction*>(instr)->barrier;
    case Format::DS:
       return barrier_shared;
    case Format::SOPP:
@@ -489,7 +460,7 @@ enum HazardResult {
    /* Must stop at these failures. The hazard query code doesn't consider them
     * when added. */
    hazard_fail_exec,
-   hazard_fail_memtime,
+   hazard_fail_unreorderable,
 };
 
 HazardResult perform_hazard_query(hazard_query *query, Instruction *instr)
@@ -507,11 +478,16 @@ HazardResult perform_hazard_query(hazard_query *query, Instruction *instr)
    if (instr->format == Format::EXP)
       return hazard_fail_export;
 
-   /* don't move s_memtime/s_memrealtime */
-   if (instr->opcode == aco_opcode::s_memtime || instr->opcode == aco_opcode::s_memrealtime)
-      return hazard_fail_memtime;
+   /* don't move non-reorderable instructions */
+   if (instr->opcode == aco_opcode::s_memtime ||
+       instr->opcode == aco_opcode::s_memrealtime ||
+       instr->opcode == aco_opcode::s_setprio)
+      return hazard_fail_unreorderable;
 
-   if (query->barrier_interaction && (query->barrier_interaction & parse_barrier(instr)))
+   barrier_interaction bar = parse_barrier(instr);
+   if (query->barrier_interaction && (query->barrier_interaction & bar))
+      return hazard_fail_barrier;
+   if (bar && query->barriers && (query->barriers & ~bar))
       return hazard_fail_barrier;
    if (query->barriers && (query->barriers & get_barrier_interaction(instr)))
       return hazard_fail_barrier;
@@ -571,7 +547,7 @@ void schedule_SMEM(sched_ctx& ctx, Block* block,
       bool can_move_down = true;
 
       HazardResult haz = perform_hazard_query(&hq, candidate.get());
-      if (haz == hazard_fail_reorder_ds || haz == hazard_fail_spill || haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier)
+      if (haz == hazard_fail_reorder_ds || haz == hazard_fail_spill || haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier || haz == hazard_fail_export)
          can_move_down = false;
       else if (haz != hazard_success)
          break;
@@ -620,7 +596,8 @@ void schedule_SMEM(sched_ctx& ctx, Block* block,
       if (found_dependency) {
          HazardResult haz = perform_hazard_query(&hq, candidate.get());
          if (haz == hazard_fail_reorder_ds || haz == hazard_fail_spill ||
-             haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier)
+             haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier ||
+             haz == hazard_fail_export)
             is_dependency = true;
          else if (haz != hazard_success)
             break;
@@ -711,7 +688,8 @@ void schedule_VMEM(sched_ctx& ctx, Block* block,
 
       HazardResult haz = perform_hazard_query(part_of_clause ? &clause_hq : &indep_hq, candidate.get());
       if (haz == hazard_fail_reorder_ds || haz == hazard_fail_spill ||
-          haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier)
+          haz == hazard_fail_reorder_sendmsg || haz == hazard_fail_barrier ||
+          haz == hazard_fail_export)
          can_move_down = false;
       else if (haz != hazard_success)
          break;
@@ -757,7 +735,7 @@ void schedule_VMEM(sched_ctx& ctx, Block* block,
          HazardResult haz = perform_hazard_query(&indep_hq, candidate.get());
          if (haz == hazard_fail_reorder_ds || haz == hazard_fail_spill ||
              haz == hazard_fail_reorder_vmem_smem || haz == hazard_fail_reorder_sendmsg ||
-             haz == hazard_fail_barrier)
+             haz == hazard_fail_barrier || haz == hazard_fail_export)
             is_dependency = true;
          else if (haz != hazard_success)
             break;
@@ -822,7 +800,7 @@ void schedule_position_export(sched_ctx& ctx, Block* block,
          break;
 
       HazardResult haz = perform_hazard_query(&hq, candidate.get());
-      if (haz == hazard_fail_exec || haz == hazard_fail_export || haz == hazard_fail_memtime)
+      if (haz == hazard_fail_exec || haz == hazard_fail_unreorderable)
          break;
 
       if (haz != hazard_success) {
@@ -868,7 +846,7 @@ void schedule_block(sched_ctx& ctx, Program *program, Block* block, live& live_v
       }
    }
 
-   if ((program->stage & hw_vs) && block->index == program->blocks.size() - 1) {
+   if ((program->stage & (hw_vs | hw_ngg_gs)) && (block->kind & block_kind_export_end)) {
       /* Try to move position exports as far up as possible, to reduce register
        * usage and because ISA reference guides say so. */
       for (unsigned idx = 0; idx < block->instructions.size(); idx++) {