[pace-fix] refactor ping pong input and output buffer using existing IPs.

Interface is verified with stallability from the memory side.
the pace.py test stimuli generation is updated with exp function also.
hwpe-stream IP points to a bug fix in fence module

Author: arpansur

.gitignore

@@ -0,0 +1,9 @@
+**venv
+**.bender
+target/sim/vsim/work/
+sw/build/
+golden-model/**/txt/
+target/sim/vsim/vsim.wlf
+sw/inc/*
+.bender/** */
+target/sim/vsim/transcript**

Bender.yml

@@ -15,7 +15,7 @@ dependencies:
   cv32e40p          : { git: "https://github.com/pulp-platform/cv32e40p.git"          , rev: "astral-v1.0"                            }
   cv32e40x          : { git: "https://github.com/pulp-platform/cv32e40x.git"          , rev: "redmule-v1.0"                           }
   ibex              : { git: "https://github.com/pulp-platform/ibex.git"              , rev: pulpissimo-v6.1.2                        }
-  hwpe-stream       : { git: "https://github.com/pulp-platform/hwpe-stream.git"       , rev: db62a6411a7f3dc2b2a74e202377da118a4a6673 } #branch: ab/strb_fix
+  hwpe-stream       : { git: "https://github.com/pulp-platform/hwpe-stream.git"       , rev: 7eb50a7cb37dc2a970e0cfee10aff5d961e41340 } #branch: ab/strb_fix
   hwpe-ctrl         : { git: "https://github.com/pulp-platform/hwpe-ctrl.git"         , rev: 0e95510c0f4d43452d21b7723d766ae92e45c101 } # branch: yt/task-interfaces
   hci               : { git: "https://github.com/pulp-platform/hci.git"               , rev: fa625bdb824209bc2c0faaa6d99ec15ff981473f } # branch: ab/fifo_options
   fpnew             : { git: "https://github.com/pulp-platform/cvfpu.git"             , rev: "pulp-v0.1.3"                            }

golden-model/FP16/scripts/pace.py

@@ -15,6 +15,9 @@ def float16_to_hex(f16_val):
 def silu(x):
     return x / (1 + np.exp(-x))
 
+def exp(x):
+    return np.exp(x)
+
 # === BST Partitioning ===
 
 def build_bst_indices(n_partitions):
@@ -61,7 +64,7 @@ def piecewise_poly_approx_bst_fp16(
 
     coeffs = []
     for i in range(partitions):
-        x = np.linspace(raw_bps[i], raw_bps[i + 1], 50).astype(np.float16)
+        x = np.linspace(raw_bps[i], raw_bps[i + 1], 500).astype(np.float16)
         y = func(x.astype(np.float32)).astype(np.float16)
         p = np.polynomial.Polynomial.fit(x.astype(np.float32), y.astype(np.float32), deg=degree,
                                          domain=[float(raw_bps[i]), float(raw_bps[i + 1])])
@@ -73,6 +76,7 @@ def piecewise_poly_approx_bst_fp16(
     y_approx = np.zeros_like(x_vals)
 
     debug_lines = []
+    custom_debug_lines = []
 
     # breakpoint layout
     debug_lines.append("=== Raw Breakpoints (sorted) ===")
@@ -115,23 +119,27 @@ def piecewise_poly_approx_bst_fp16(
         dbg.append(f"  y_approx  = {y_approx[idx]:.5f} ({float16_to_hex(y_approx[idx])})")
         dbg.append(f"  error     = {float(y_true[idx] - y_approx[idx]):.5f}")
         debug_lines.append("\n".join(dbg) + "\n")
+        if idx % 16 == 0:
+            custom_debug_lines.append("\n".join(dbg))
 
     return {
         "x_vals": x_vals,
         "y_true": y_true,
         "y_approx": y_approx,
         "breakpoints_bst": breakpoints_bst,
         "coeffs": coeffs,
-        "debug_lines": debug_lines
+        "debug_lines": debug_lines,
+        "custom_debug_lines": custom_debug_lines
     }
 
 
 def write_debug_output(results, debug_file="execution.txt"):
     with open(debug_file, "w") as f:
-        for line in results["debug_lines"]:
+        for line in results:
             f.write(line + "\n")
     print(f"✅ Debug written to: {debug_file}")
 
+
 def write_coefficients_output(results, coeff_file="coefficients.txt"):
     with open(coeff_file, "w") as f:
         for i, coeffs in enumerate(results["coeffs"]):
@@ -245,8 +253,8 @@ def write_tensor_dim_inc_file(stimuli_file = "tensor_dim.h", n_tests=1000):
     f_d.write('#ifndef __TENSOR_DIM__\n'       )
     f_d.write('#define __TENSOR_DIM__\n\n'     )
     f_d.write('#define M_SIZE  8 \n'           )
-    f_d.write('#define N_SIZE  32\n'            )
-    f_d.write(f'#define K_SIZE  {n_tests/8} \n')
+    f_d.write('#define N_SIZE  64\n'            )
+    f_d.write(f'#define K_SIZE  {n_tests/32} \n')
     f_d.write('#define SRC_FMT FP16\n'         )
     f_d.write('#define DST_FMT FP16\n'         )
     f_d.write('#define FPFORMAT 16\n'          )
@@ -258,27 +266,28 @@ def write_tensor_dim_inc_file(stimuli_file = "tensor_dim.h", n_tests=1000):
 if __name__ == "__main__":
     import argparse
     parser = argparse.ArgumentParser("PACE Operation Test")
-    parser.add_argument( '--x_min',     type=int, default=-6 )
-    parser.add_argument( '--x_max',     type=int, default=6 )
+    parser.add_argument( '--x_min',     type=int, default=-11 )
+    parser.add_argument( '--x_max',     type=int, default=0 )
     parser.add_argument( '--f_name',    type=str, default="silu" )
     parser.add_argument( '--n_parts',   type=int, default=8 )
     parser.add_argument( '--n_deg',     type=int, default=4 )
-    parser.add_argument( '--n_tests',   type=int, default=1024 )
+    parser.add_argument( '--n_tests',   type=int, default=4096 )
     parser.add_argument( '--file_name', type=str, default='net_parameters.h')
     parser.add_argument( '--inc_dir',   type=str)
     parser.add_argument( '--txt_dir',   type=str)
     args = parser.parse_args()
     results = piecewise_poly_approx_bst_fp16(
-        silu, xmin=-6, xmax=6, degree=4, partitions=8, n_stimuli=args.n_tests
+        exp, xmin=args.x_min, xmax=args.x_max, degree=4, partitions=8, n_stimuli=args.n_tests
     )
-    write_debug_output(debug_file=os.path.join(args.txt_dir,"execution.txt"),results=results)
+    write_debug_output(debug_file=os.path.join(args.txt_dir,"execution.txt"),results=results["debug_lines"])
+    write_debug_output(debug_file=os.path.join(args.txt_dir,"execution_custom.txt"),results=results["custom_debug_lines"])
     write_coefficients_output(coeff_file=os.path.join(args.txt_dir,"coefficients.txt"), results=results)
     write_inp_inc_file(results, stimuli_file=os.path.join(args.inc_dir, "w_input.h"))
     write_golden_oup_inc_file(results, stimuli_file=os.path.join(args.inc_dir, "golden.h"))
     write_actual_oup_inc_file(results, stimuli_file=os.path.join(args.inc_dir, "z_output.h"))
     write_golden_inc_debug_file(results, stimuli_file=os.path.join(args.txt_dir, "golden_debug.h"))
     write_y_inp_inc_file(stimuli_file=os.path.join(args.inc_dir, "y_input.h"))
-    write_x_file(coeffs=results["coeffs"], xmin=-6, xmax=6, partitions=8, stimuli_file=os.path.join(args.inc_dir, "x_input.h")) 
+    write_x_file(coeffs=results["coeffs"], xmin=args.x_min, xmax=args.x_max, partitions=8, stimuli_file=os.path.join(args.inc_dir, "x_input.h")) 
     write_tensor_dim_inc_file(stimuli_file=os.path.join(args.inc_dir, "tensor_dim.h"), n_tests=args.n_tests)
 
 

rtl/pace/pace_pingpong_inp.sv

@@ -6,29 +6,40 @@
 //
 // This module takes a 256b data and splits it to 128b to feed it to the engine for 2 cycles.
 module pace_pingpong_inp #(
-  parameter int unsigned InpDataWidth  = 256,
-  parameter int unsigned NumRows       = 8,
-  parameter int unsigned OupDataWidth  = 16
+  parameter int unsigned InpDataWidth    = 256,
+  parameter int unsigned NumRows         = 8,
+  parameter int unsigned CEOupDataWidth  = 16,
+  localparam int unsigned OupDataWidth   = NumRows * CEOupDataWidth
 ) (
   input  logic                                    clk_i,
   input  logic                                    rst_ni,
   input  logic                                    clear_i,
   input  logic                                    enable_i,
-  output logic [NumRows-1:0][OupDataWidth-1:0]    output_o,
+  output logic [NumRows-1:0][CEOupDataWidth-1:0]  output_o,
   output logic                                    valid_o,
   input  logic                                    ready_i,
   hwpe_stream_intf_stream.sink                    input_i
 );
 
   // Local signals
   hwpe_stream_intf_stream #(
-    .DATA_WIDTH ( InpDataWidth*NumRows )
+    .DATA_WIDTH (InpDataWidth/2 )
   ) ping_pong_buffer [1:0] (
     .clk ( clk_i )
   );
-  logic                            output_handshake;
-  logic [NumRows*OupDataWidth-1:0] output_buffer;
-  logic                            ping_pong_status_d, ping_pong_status_q;
+
+  hwpe_stream_intf_stream #(
+    .DATA_WIDTH ( InpDataWidth/2 )
+  ) output_buffer (
+    .clk ( clk_i )
+  );
+
+  hwpe_stream_intf_stream #(
+    .DATA_WIDTH ( InpDataWidth/2 )
+  ) output_buffer_fifo (
+    .clk ( clk_i )
+  );
+
 
   // Stream splitter
   hwpe_stream_split #(
@@ -42,33 +53,49 @@ module pace_pingpong_inp #(
     .pop_o   ( ping_pong_buffer )
   );
 
-  // Ready/valid handshake
-  assign ping_pong_buffer[0].ready = output_handshake & ping_pong_status_q & enable_i;
-  assign ping_pong_buffer[1].ready = output_handshake & ping_pong_status_q & enable_i;
+  hwpe_stream_package::ctrl_serdes_t ctrl_serdes;
 
-  assign output_buffer = ping_pong_status_q ? ping_pong_buffer[1].data  : ping_pong_buffer[0].data;
-  assign valid_o       = ping_pong_status_q ? ping_pong_buffer[1].valid : ping_pong_buffer[0].valid;
+  assign ctrl_serdes.clear_serdes_state = clear_i;
+  assign ctrl_serdes.nb_contig_m1       = 0;
+  assign ctrl_serdes.first_stream       = 1'b0;
+
+  hwpe_stream_serialize #(
+    .NB_IN_STREAMS ( 2            ),
+    .CONTIG_LIMIT  ( 1024         ),
+    .DATA_WIDTH    ( OupDataWidth ),
+    .SYNC_READY    ( 1'b1         )
+  ) i_hwpe_stream_serialize (
+    .clk_i   ( clk_i            ),
+    .rst_ni  ( rst_ni           ),
+    .clear_i ( clear_i          ),
+    .ctrl_i  ( ctrl_serdes      ),
+    .push_i  ( ping_pong_buffer ),
+    .pop_o   ( output_buffer    )
+  );
+
+  hwpe_stream_fifo #(
+    .DATA_WIDTH ( OupDataWidth ),
+    .FIFO_DEPTH ( 2            ),
+    .LATCH_FIFO ( 0            ),
+    .LATCH_FIFO_TEST_WRAP ( 0  )
+  ) i_hwpe_stream_fifo (
+    .clk_i   ( clk_i              ),
+    .rst_ni  ( rst_ni             ),
+    .clear_i ( clear_i            ),
+    .flags_o (                    ),
+    .push_i  ( output_buffer      ),
+    .pop_o   ( output_buffer_fifo )
+  );
 
   // Output slicing
   generate
     for (genvar r = 0; r < NumRows; r++) begin : gen_output_unpack
-      assign output_o[r] = output_buffer[(OupDataWidth*(r+1))-1 -: OupDataWidth];
+      assign output_o[r] = output_buffer_fifo.data[(CEOupDataWidth*(r+1))-1 -: CEOupDataWidth];
     end
   endgenerate
+  assign valid_o = output_buffer_fifo.valid;
+  assign output_buffer_fifo.ready = ready_i & enable_i;
 
-  // Handshake logic
-  assign output_handshake = valid_o & ready_i;
 
-  // Ping-pong control
-  assign ping_pong_status_d = clear_i             ? 1'b0 :
-                              output_handshake    ? ~ping_pong_status_q :
-                                                    ping_pong_status_q;
-  always_ff @(posedge clk_i or negedge rst_ni) begin : gen_ping_pong_status_ff
-    if (~rst_ni) begin
-      ping_pong_status_q <= 1'b0;
-    end else begin
-      ping_pong_status_q <= ping_pong_status_d;
-    end
-  end
 
 endmodule