build fixes

Author: tinebp

hw/rtl/core/VX_ibuffer.sv

@@ -65,8 +65,8 @@ module VX_ibuffer import VX_gpu_pkg::*; #(
                 decode_if.data.rs1,
                 decode_if.data.rs2,
                 decode_if.data.rs3,
-                1'b0, // fu_lock
-                1'b0  // fu_unlock
+                1'b1, // fu_lock
+                1'b1  // fu_unlock
             }),
             .ready_in (ibuf_ready_in[w]),
             .valid_out(ibuffer_tmp_if.valid),

hw/rtl/core/VX_scoreboard.sv

@@ -204,9 +204,8 @@ module VX_scoreboard import VX_gpu_pkg::*; #(
     wire [PER_ISSUE_WARPS-1:0] fu_lock_block;
     for (genvar w = 0; w < PER_ISSUE_WARPS; ++w) begin : g_fu_lock_block
         wire [EX_BITS-1:0] w_ex = staging_if[w].data.ex_type;
-        // Block warps when FU is locked. Owner warp's uops have fu_lock=1
-        // (set by the uop expander) and bypass the block.
-        assign fu_lock_block[w] = fu_locked[w_ex] && ~staging_if[w].data.fu_lock;
+        // Block warps when FU is locked. fu_lock=1 means acquire request.
+        assign fu_lock_block[w] = fu_locked[w_ex] && staging_if[w].data.fu_lock;
     end
 
     for (genvar w = 0; w < PER_ISSUE_WARPS; ++w) begin : g_arb_data_in
@@ -276,9 +275,7 @@ module VX_scoreboard import VX_gpu_pkg::*; #(
     assign arb_ready = ready_out_w;
 
     // FU lock: prevent warp interleaving during multi-uop sequences.
-    // fu_lock=1 on all uops of a locked sequence (set by uop expander).
-    // fu_unlock=1 on the last uop releases the lock.
-    // Non-owner warps have fu_lock=0 and are blocked while fu_locked is set.
+    // 10=acquire (first uop), 00=middle, 01=release (last uop), 11=default.
 
     wire issue_fire = valid_out_w && ready_out_w;
 
@@ -299,10 +296,10 @@ module VX_scoreboard import VX_gpu_pkg::*; #(
         if (reset) begin
             fu_locked <= '0;
         end else if (issue_fire) begin
-            if (issue_fu_unlock) begin
-                fu_locked[issue_ex] <= 1'b0;
-            end else if (issue_fu_lock) begin
+            if (issue_fu_lock && ~issue_fu_unlock) begin
                 fu_locked[issue_ex] <= 1'b1;
+            end else if (~issue_fu_lock && issue_fu_unlock) begin
+                fu_locked[issue_ex] <= 1'b0;
             end
         end
     end

hw/rtl/tcu/VX_tcu_uops.sv

@@ -377,10 +377,8 @@ module VX_tcu_uops import VX_tcu_pkg::*, VX_gpu_pkg::*; (
         ibuf_r.used_rs[2] = wmma_is_first_k;
     `endif
         end
-        // Lock the FU during the entire macro-op sequence.
-        // fu_lock=1 on all uops identifies this as part of a locked sequence.
-        // fu_unlock=1 on the last uop releases the lock after issue.
-        ibuf_r.fu_lock   = 1'b1;
+        // FU lock: 10=acquire (first), 00=middle, 01=release (last).
+        ibuf_r.fu_lock   = (uop_idx == UOP_CTR_W'(0));
         ibuf_r.fu_unlock = (uop_idx == (uop_count - UOP_CTR_W'(1)));
     end
 

sim/simx/core.cpp

@@ -386,10 +386,10 @@ void Core::issue() {
       } else {
         uop_trace->log_once(false);
         // FU lock: block warps whose target FU is locked by another warp.
-        // Owner warp's uops have fu_lock=1 (set by uop expander) and bypass.
+        // fu_lock=1 means acquire request; blocked when FU already locked.
         auto fu = (int)uop_trace->fu_type;
         bool uop_fu_lock = uop_trace->instr_ptr->get_fu_lock();
-        if (fu_locked_.test(fu) && !uop_fu_lock) {
+        if (fu_locked_.test(fu) && uop_fu_lock) {
           continue; // blocked by FU lock
         }
         ready_set.set(w); // mark instruction as ready
@@ -427,13 +427,15 @@ void Core::issue() {
           // update scoreboard
           scoreboard_.reserve(uop_trace);
         }
-        // Update FU lock state
+        // Update FU lock state: 10=acquire, 01=release
         {
-          auto fu = (int)uop_trace->fu_type;
-          if (uop_trace->instr_ptr->get_fu_unlock()) {
-            fu_locked_.reset(fu);
-          } else if (uop_trace->instr_ptr->get_fu_lock()) {
-            fu_locked_.set(fu);
+          auto fui = (int)uop_trace->fu_type;
+          bool fl = uop_trace->instr_ptr->get_fu_lock();
+          bool ful = uop_trace->instr_ptr->get_fu_unlock();
+          if (fl && !ful) {
+            fu_locked_.set(fui);
+          } else if (!fl && ful) {
+            fu_locked_.reset(fui);
           }
         }
         // Advance sequencer; pop ibuffer only when all micro-ops issued

sim/simx/decode.cpp

@@ -393,7 +393,7 @@ static op_string_t op_string(const Instr &instr) {
 #endif
   #ifdef EXT_V_ENABLE
     ,[&](VsetType vset_type)-> op_string_t {
-      auto vset_args = std::get<IntrVset_args>(instrArgs);
+      auto vset_args = std::get<IntrVsetArgs>(instrArgs);
       switch (vset_type) {
       case VsetType::VSETVLI:  return {"VSETVLI", vset_args.to_string(vset_type)};
       case VsetType::VSETIVLI: return {"VSETIVLI", vset_args.to_string(vset_type)};
@@ -935,17 +935,17 @@ Instr::Ptr Emulator::decode(uint32_t code, uint32_t /*wid*/, uint64_t uuid) {
       instr->set_dest_reg(rd, RegType::Integer);
       if ((code >> 30) == 0b10) { // vsetvl
         instr->set_op_type(VsetType::VSETVL);
-        instr->set_args(IntrVset_args{0, 0});
+        instr->set_args(IntrVsetArgs{0, 0});
         instr->set_src_reg(0, rs1, RegType::Integer);
         instr->set_src_reg(1, rs2, RegType::Integer);
       } else {
         auto zimm = (code >> shift_vzimm) & mask_vzimm;
         if ((code >> 30) == 0b11) { // vsetivli
           instr->set_op_type(VsetType::VSETIVLI);
-          instr->set_args(IntrVset_args{zimm, rs1});
+          instr->set_args(IntrVsetArgs{zimm, rs1});
         } else { // vsetvli
           instr->set_op_type(VsetType::VSETVLI);
-          instr->set_args(IntrVset_args{zimm, 0});
+          instr->set_args(IntrVsetArgs{zimm, 0});
           instr->set_src_reg(0, rs1, RegType::Integer);
         }
       }

sim/simx/tensor_unit.cpp

@@ -1305,8 +1305,8 @@ Instr::Ptr TcuUopGen::get(const Instr& macro_instr, uint32_t uop_index) {
 #endif
 
   // fu_lock/fu_unlock: prevent warp interleaving during TCU K-accumulation.
-  // fu_lock=1 on all uops identifies the owner; fu_unlock=1 on last releases.
-  uop_instr->set_fu_lock(true);
+  // 10=acquire (first), 00=middle, 01=release (last), 11=default (non-sequenced).
+  uop_instr->set_fu_lock(uop_index == 0);
   uop_instr->set_fu_unlock(uop_index == total - 1);
 
   return uop_instr;