remove redundant 'commented-out' old code

Author: symmetryyyyy

hw/rtl/core/VX_schedule.sv

@@ -87,7 +87,6 @@ module VX_schedule import VX_gpu_pkg::*; #(
     // barriers
     reg [`NUM_BARRIERS-1:0][`NUM_WARPS-1:0] barrier_masks, barrier_masks_n;
     reg [`NUM_BARRIERS-1:0][NW_WIDTH-1:0] barrier_ctrs, barrier_ctrs_n;
-    // reg [`NUM_WARPS-1:0] barrier_stalls, barrier_stalls_n;
     reg [`NUM_WARPS-1:0] curr_barrier_mask_p1;
 
     // async barriers (things I think should be kept separate state from sync barrier)
@@ -115,7 +114,6 @@ module VX_schedule import VX_gpu_pkg::*; #(
         thread_masks_n  = thread_masks;
         barrier_masks_n = barrier_masks;
         barrier_ctrs_n  = barrier_ctrs;
-        // barrier_stalls_n= barrier_stalls;
         warp_pcs_n      = warp_pcs;
 
         // async barrier next state
@@ -168,27 +166,10 @@ module VX_schedule import VX_gpu_pkg::*; #(
 
         // barrier handling
         curr_barrier_mask_p1 = '0;
-        // curr_barrier_mask_p1 = barrier_masks[warp_ctl_if.barrier.id];
-        // curr_barrier_mask_p1[warp_ctl_if.wid] = 1;
         if (warp_ctl_if.valid && warp_ctl_if.barrier.valid) begin
             curr_barrier_mask_p1 = barrier_masks[warp_ctl_if.barrier.id];
             curr_barrier_mask_p1[warp_ctl_if.wid] = 1;
 
-            // if (~warp_ctl_if.barrier.is_noop) begin
-            //     if (~warp_ctl_if.barrier.is_global
-            //      && (barrier_ctrs[warp_ctl_if.barrier.id] == NW_WIDTH'(warp_ctl_if.barrier.size_m1))) begin
-            //         barrier_ctrs_n[warp_ctl_if.barrier.id] = '0; // reset barrier counter
-            //         barrier_masks_n[warp_ctl_if.barrier.id] = '0; // reset barrier mask
-            //         stalled_warps_n &= ~barrier_masks[warp_ctl_if.barrier.id]; // unlock warps
-            //         stalled_warps_n[warp_ctl_if.wid] = 0; // unlock warp
-            //     end else begin
-            //         barrier_ctrs_n[warp_ctl_if.barrier.id] = barrier_ctrs[warp_ctl_if.barrier.id] + NW_WIDTH'(1);
-            //         barrier_masks_n[warp_ctl_if.barrier.id] = curr_barrier_mask_p1;
-            //     end
-            // end else begin
-            //     stalled_warps_n[warp_ctl_if.wid] = 0; // unlock warp
-            // end
-
             case (warp_ctl_if.barrier.op)
                 BARRIER_OP_SYNC: begin
                     if (~warp_ctl_if.barrier.is_noop) begin

hw/rtl/core/VX_wctl_unit.sv

@@ -32,8 +32,6 @@ module VX_wctl_unit import VX_gpu_pkg::*; #(
     localparam PID_BITS   = `CLOG2(`NUM_THREADS / NUM_LANES);
     localparam WCTL_WIDTH = $bits(tmc_t) + $bits(wspawn_t) + $bits(split_t) + $bits(join_t) + $bits(barrier_t);
 
-    // localparam DATAW = UUID_WIDTH + NW_WIDTH + NUM_LANES + PC_BITS + NUM_REGS_BITS + 1 + PID_WIDTH + 1 + 1 + DV_STACK_SIZEW + `XLEN + 1;
-
     `UNUSED_VAR (execute_if.data.rs3_data)
 
     tmc_t       tmc;

kernel/include/vx_spawn.h

@@ -75,11 +75,6 @@ void vx_serial(vx_serial_cb callback, const void * arg);
 //////////////////////////////////////////////////////////////////////////////
 
 // CTA-level async barrier
-// Usage:
-//   barrier bar;
-//   bar.init(num_warps);
-//   uint32_t token = bar.arrive();  // returns token (generation number)
-//   bar.wait(token);                // wait until generation > token
 class barrier {
 public:
   // Constructor

sim/simx/emulator.cpp

@@ -306,14 +306,6 @@ uint32_t Emulator::barrier_arrive(uint32_t bar_id, uint32_t count, uint32_t wid)
     // Capture current generation as token BEFORE any updates
     uint32_t token = b.generation;
 
-    std::cout << "[ARRIVE] warp=" << wid
-              << " gen =" << b.generation
-              << " token=" << token
-              << " expect =" << b.expect_count
-              << " arrived_count =" << b.arrived_count
-              << " arrived_mask =" << b.arrived_mask
-              << std::endl;
-
     // If arrived in the same generation before, skip but still return token
     if (b.arrived_mask.test(wid)) {
         std::cout << "  >> ARRIVE_DUP warp=" << wid << " (already arrived this gen)\n";
@@ -324,18 +316,11 @@ uint32_t Emulator::barrier_arrive(uint32_t bar_id, uint32_t count, uint32_t wid)
     b.arrived_mask.set(wid);
     ++b.arrived_count;
 
-    std::cout << " [ARRIVE_UPDATE] warp=" << wid
-              << " arrived_count=" << b.arrived_count
-              << " arrived_mask=" << b.arrived_mask
-              << std::endl;
 
     // If all warps arrived, update the generation
     if (b.arrived_count == b.expect_count) {
         uint32_t new_gen = b.generation + 1;
 
-        std::cout << " [GENERATION COMPLETE]: gen="
-                  << b.generation << " -> " << new_gen << std::endl;
-
         b.generation = new_gen;
         b.arrived_count = 0;
         b.arrived_mask.reset();
@@ -345,9 +330,6 @@ uint32_t Emulator::barrier_arrive(uint32_t bar_id, uint32_t count, uint32_t wid)
             if (b.waiting_mask.test(w)) {
                 // Check if this warp's token indicates it should wake up
                 // A warp waiting with token T should wake when generation > T
-                std::cout << "  [CHECK WAKE warp] =" << w
-                          << " now_gen =" << b.generation
-                          << std::endl;
                 b.waiting_mask.reset(w);
                 stalled_warps_.reset(w);
             }
@@ -381,43 +363,21 @@ bool Emulator::barrier_wait(uint32_t bar_id, uint32_t token, uint32_t wid) {
     // We need to wait until generation > token (i.e., that phase completed)
     uint32_t desired_gen = token + 1;
 
-    std::cout << "[WAIT] warp=" << wid
-              << " token=" << token
-              << " desired_gen=" << desired_gen
-              << " current_gen=" << b.generation
-              << " arrived_mask=" << b.arrived_mask
-              << " waiting_mask=" << b.waiting_mask
-              << std::endl;
-
     if (b.generation >= desired_gen) {
-        std::cout << "[WAIT_DONE] warp=" << wid
-                  << " reaches gen=" << b.generation
-                  << " (desired=" << desired_gen << ", token=" << token << ")"
-                  << std::endl;
+ 
 
         b.waiting_mask.reset(wid);
         stalled_warps_.reset(wid);
 
-        std::cout << "waiting_mask(after pass)="
-                  << b.waiting_mask
-                  << std::endl;
 
         return true;
     }
 
     // Not reached, wait
-    std::cout << "  warp " << wid
-              << " waiting for gen " << desired_gen
-              << " (current gen=" << b.generation << ", token=" << token << ")"
-              << std::endl;
 
     b.waiting_mask.set(wid);
     stalled_warps_.set(wid);
 
-    std::cout << "waiting_mask(after stall)="
-              << b.waiting_mask
-              << std::endl;
-
     return false;
 }
 

sim/simx/execute.cpp

@@ -1391,9 +1391,6 @@ instr_trace_t* Emulator::execute(const Instr &instr, uint32_t wid) {
         trace->data = std::make_shared<SfuTraceData>(rs1_data[thread_last].i, rs2_data[thread_last].i);
       } break;
       case WctlType::BAR_ARRIVE: {
-        // Asynchronous arrive - non-blocking
-        // rs1 = barrier_id, rs2 = num_warps
-        // Returns token (current generation) in rd
         uint32_t bar_id = rs1_data[thread_last].u;
         uint32_t count = rs2_data[thread_last].u;
         uint32_t token = this->barrier_arrive(bar_id, count, wid);
@@ -1405,14 +1402,9 @@ instr_trace_t* Emulator::execute(const Instr &instr, uint32_t wid) {
         rd_write = true;
       } break;
       case WctlType::BAR_WAIT: {
-        // Asynchronous wait - blocking if barrier generation <= token
-        // rs1 = barrier_id, rs2 = token (from previous arrive)
         uint32_t bar_id = rs1_data[thread_last].u;
         uint32_t token = rs2_data[thread_last].u;
-        // bool ready = this->barrier_wait(bar_id, token, wid);
-        // if (!ready) {
         trace->fetch_stall = true;  // Stall until barrier reaches next generation
-        // }
         trace->data = std::make_shared<SfuTraceData>(bar_id, token);
       } break;
       case WctlType::PRED: {

sim/simx/func_unit.cpp

@@ -398,16 +398,12 @@ void SfuUnit::tick() {
 				}
 			} break;
 			case WctlType::BAR_ARRIVE: {
-				// Arrive is non-blocking, just pass through the pipeline
-				// Barrier logic and token generation happen in execute.cpp
 				output.send(trace, 2+delay);
 			} break;
 			case WctlType::BAR_WAIT: {
 				output.send(trace, 2+delay);
 				if (trace->eop) {
 					auto trace_data = std::dynamic_pointer_cast<SfuTraceData>(trace->data);
-					// arg1 = barrier_id, arg2 = token (from arrive)
-					// Re-check if barrier is ready, for warp scheduling
 					release_warp = core_->barrier_wait(trace_data->arg1, trace_data->arg2, trace->wid);
 				}
 			} break;