diff --git a/.justfile b/.justfile index 325cb2a..958bb31 100644 --- a/.justfile +++ b/.justfile @@ -76,11 +76,11 @@ cam-test MODULE TESTCASE: # Run CAM retrieval benchmark without hardware noise cam-test-retrieval-no-noise: - just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 WRITE_NOISE_EN=0 READ_NOISE_EN=0" + just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 WRITE_NOISE_EN=0" -# Run CAM retrieval benchmark with read noise enabled +# Run CAM retrieval benchmark with write noise enabled (Phase 2: read noise removed) cam-test-retrieval-read-noise: - just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 WRITE_NOISE_EN=0 READ_NOISE_EN=1 READ_NOISE_RATE_NUM=1 READ_NOISE_RATE_DEN=100 READ_NOISE_BITS=8" + just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 WRITE_NOISE_EN=1 WRITE_NOISE_RATE_NUM=1 WRITE_NOISE_RATE_DEN=100" # Prepare CIFAR10 hash artifact for CAM retrieval smoke benchmark cam-prepare-retrieval-cifar10 ROWS="512" QUERIES="128": @@ -92,8 +92,8 @@ cam-prepare-retrieval-cifar100 ROWS="512" QUERIES="128": # Run CAM retrieval benchmark on a prepared artifact without hardware noise cam-test-retrieval-artifact DATASET_PATH NUM_ROWS="4096": - just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 NUM_ROWS={{NUM_ROWS}} WRITE_NOISE_EN=0 READ_NOISE_EN=0 CAM_RETRIEVAL_DATASET={{ DATASET_PATH }}" + just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 NUM_ROWS={{NUM_ROWS}} WRITE_NOISE_EN=0 CAM_RETRIEVAL_DATASET={{ DATASET_PATH }}" -# Run CAM retrieval benchmark on a prepared artifact with read noise enabled +# Run CAM retrieval benchmark on a prepared artifact with write noise enabled (Phase 2: read noise removed) cam-test-retrieval-artifact-read-noise DATASET_PATH NUM_ROWS="4096": - just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 NUM_ROWS={{NUM_ROWS}} WRITE_NOISE_EN=0 READ_NOISE_EN=1 READ_NOISE_RATE_NUM=1 READ_NOISE_RATE_DEN=100 READ_NOISE_BITS=8 CAM_RETRIEVAL_DATASET={{ DATASET_PATH }}" + just remote "make -C hw/sim clean && make -C hw/sim test-benchmark-retrieval TOPK_K=5 NUM_ROWS={{NUM_ROWS}} WRITE_NOISE_EN=1 WRITE_NOISE_RATE_NUM=1 WRITE_NOISE_RATE_DEN=100 CAM_RETRIEVAL_DATASET={{ DATASET_PATH }}" diff --git a/.stignore b/.stignore index 6eb4476..b7091bc 100644 --- a/.stignore +++ b/.stignore @@ -7,6 +7,7 @@ .ruff_cache .opencode .backup +.codegraph data datasets deps diff --git a/docs/experiments.md b/docs/experiments.md index 0b22dd5..0fcef38 100644 --- a/docs/experiments.md +++ b/docs/experiments.md @@ -31,7 +31,7 @@ - `hw/rtl/core/popcount_pipeline.sv` - `hw/rtl/noise/cam_write_noise.sv` - `hw/rtl/noise/cam_read_noise.sv` -- `hw/rtl/noise/noise_mask_grouped.sv` +- `hw/rtl/noise/noise_mask_bernoulli.sv`（Phase 2 后 read noise 改为 pass-through，该模块仅用于 write noise mask 生成） - `hw/rtl/cam_params.svh` - `hw/sim/model/ref_model.py` - `hw/sim/sweep_noise.py` @@ -129,7 +129,7 @@ - 写入/读取：`hw/rtl/core/cam_core_banked.sv`、`hw/sim/tests/test_cam_core_banked.py` - 匹配与 popcount：`hw/rtl/core/match_engine_pipeline.sv`、`hw/rtl/core/popcount_pipeline.sv` -- 噪声模块：`hw/rtl/noise/cam_write_noise.sv`、`hw/rtl/noise/cam_read_noise.sv` +- 噪声模块：`hw/rtl/noise/cam_write_noise.sv`、`hw/rtl/noise/cam_read_noise.sv`（Phase 2 后 read noise 改为 pass-through，实际翻转仅由 write noise 模块产生） - 参考模型：`hw/sim/model/ref_model.py` - 集成测试：`hw/sim/tests/test_cam_basic.py` diff --git a/hw/rtl/cam_noisy.sv b/hw/rtl/cam_noisy.sv index 438f0a2..7157067 100644 --- a/hw/rtl/cam_noisy.sv +++ b/hw/rtl/cam_noisy.sv @@ -5,13 +5,7 @@ module cam_noisy #( parameter bit WRITE_NOISE_EN = 1'b1, parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_DEN = 100, - parameter int WRITE_NOISE_BITS = 8, - parameter logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D, - parameter bit READ_NOISE_EN = 1'b1, - parameter int READ_NOISE_RATE_NUM = 1, - parameter int READ_NOISE_RATE_DEN = 100, - parameter int READ_NOISE_BITS = 8, - parameter logic [63:0] READ_NOISE_SEED = 64'h6A09_E667_F3BC_C909 + parameter logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D ) ( input logic clk, input logic rst_n, @@ -42,7 +36,6 @@ module cam_noisy #( .WRITE_NOISE_EN (WRITE_NOISE_EN), .WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), .WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN), - .WRITE_NOISE_BITS (WRITE_NOISE_BITS), .WRITE_NOISE_SEED (WRITE_NOISE_SEED) ) u_write_noise ( .clk (clk), @@ -73,13 +66,7 @@ module cam_noisy #( ); // ── Read noise pipeline ── - cam_read_noise #( - .READ_NOISE_EN (READ_NOISE_EN), - .READ_NOISE_RATE_NUM (READ_NOISE_RATE_NUM), - .READ_NOISE_RATE_DEN (READ_NOISE_RATE_DEN), - .READ_NOISE_BITS (READ_NOISE_BITS), - .READ_NOISE_SEED (READ_NOISE_SEED) - ) u_read_noise ( + cam_read_noise u_read_noise ( .clk (clk), .rst_n (rst_n), .valid_i (core_rd_valid), diff --git a/hw/rtl/cam_top.sv b/hw/rtl/cam_top.sv index 621e02c..d95f3d1 100644 --- a/hw/rtl/cam_top.sv +++ b/hw/rtl/cam_top.sv @@ -5,13 +5,7 @@ module cam_top #( parameter bit WRITE_NOISE_EN = 1'b1, parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_DEN = 100, - parameter int WRITE_NOISE_BITS = 8, - parameter logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D, - parameter bit READ_NOISE_EN = 1'b1, - parameter int READ_NOISE_RATE_NUM = 1, - parameter int READ_NOISE_RATE_DEN = 100, - parameter int READ_NOISE_BITS = 8, - parameter logic [63:0] READ_NOISE_SEED = 64'h6A09_E667_F3BC_C909 + parameter logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D ) ( input logic clk, input logic rst_n, @@ -77,13 +71,7 @@ module cam_top #( .WRITE_NOISE_EN (WRITE_NOISE_EN), .WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), .WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN), - .WRITE_NOISE_BITS (WRITE_NOISE_BITS), - .WRITE_NOISE_SEED (WRITE_NOISE_SEED), - .READ_NOISE_EN (READ_NOISE_EN), - .READ_NOISE_RATE_NUM (READ_NOISE_RATE_NUM), - .READ_NOISE_RATE_DEN (READ_NOISE_RATE_DEN), - .READ_NOISE_BITS (READ_NOISE_BITS), - .READ_NOISE_SEED (READ_NOISE_SEED) + .WRITE_NOISE_SEED (WRITE_NOISE_SEED) ) u_noisy ( .clk (clk), .rst_n (rst_n), diff --git a/hw/rtl/noise/cam_read_noise.sv b/hw/rtl/noise/cam_read_noise.sv index 8eb9ac1..d7eae8f 100644 --- a/hw/rtl/noise/cam_read_noise.sv +++ b/hw/rtl/noise/cam_read_noise.sv @@ -1,13 +1,7 @@ `timescale 1ns / 1ps `include "cam_params.svh" -module cam_read_noise #( - parameter bit READ_NOISE_EN = 1'b1, - parameter int READ_NOISE_RATE_NUM = 1, - parameter int READ_NOISE_RATE_DEN = 100, - parameter int READ_NOISE_BITS = 8, - parameter logic [63:0] READ_NOISE_SEED = 64'h6A09_E667_F3BC_C909 -) ( +module cam_read_noise ( input logic clk, input logic rst_n, input logic valid_i, @@ -19,69 +13,19 @@ module cam_read_noise #( output logic [(`LANES)*(`HASH_BITS)-1:0] hashes_noisy_o, output logic [(`LANES)-1:0] lane_valid_o ); - logic valid_q; - logic [(`LANES)*(`ROW_BITS)-1:0] row_ids_q; - logic [(`LANES)*(`HASH_BITS)-1:0] hashes_q; - logic [(`LANES)-1:0] lane_valid_q; - - logic [127:0] random_num [0:`LANES-1]; - logic [(`HASH_BITS)-1:0] mask [0:`LANES-1]; - - `ifndef SYNTHESIS - initial begin - if (READ_NOISE_SEED == 64'd0) $fatal(1, "READ_NOISE_SEED must be nonzero"); - end - `endif - - generate - for (genvar lane = 0; lane < `LANES; lane++) begin : gen_lane_noise - localparam logic [63:0] LANE_SALT = 64'(lane + 1) * 64'h9E37_79B9_7F4A_7C15; - random128 u_random_read ( - .clk (clk), - .rst_n (rst_n), - .enable(valid_i && lane_valid_i[lane] && READ_NOISE_EN && (READ_NOISE_RATE_NUM > 0)), - .seed ({(READ_NOISE_SEED ^ LANE_SALT), (READ_NOISE_SEED ^ LANE_SALT)}), - .out (random_num[lane]) - ); - - noise_mask_grouped #( - .HASH_BITS (`HASH_BITS), - .NOISE_BITS (READ_NOISE_BITS), - .NOISE_RATE_NUM (READ_NOISE_RATE_NUM), - .NOISE_RATE_DEN (READ_NOISE_RATE_DEN) - ) u_mask ( - .random_i(random_num[lane]), - .mask_o (mask[lane]) - ); - end - endgenerate always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin - valid_q <= 1'b0; - row_ids_q <= '0; - hashes_q <= '0; - lane_valid_q <= '0; valid_o <= 1'b0; row_ids_o <= '0; hashes_noisy_o <= '0; lane_valid_o <= '0; end else begin - valid_q <= valid_i; - row_ids_q <= row_ids_i; - hashes_q <= hashes_i; - lane_valid_q <= lane_valid_i; - - valid_o <= valid_q; - row_ids_o <= row_ids_q; - lane_valid_o <= lane_valid_q; - for (int lane = 0; lane < `LANES; lane++) begin - if (READ_NOISE_EN && (READ_NOISE_RATE_NUM > 0) && lane_valid_q[lane]) begin - hashes_noisy_o[lane*`HASH_BITS +: `HASH_BITS] <= hashes_q[lane*`HASH_BITS +: `HASH_BITS] ^ mask[lane]; - end else begin - hashes_noisy_o[lane*`HASH_BITS +: `HASH_BITS] <= hashes_q[lane*`HASH_BITS +: `HASH_BITS]; - end - end + valid_o <= valid_i; + row_ids_o <= row_ids_i; + hashes_noisy_o <= hashes_i; + lane_valid_o <= lane_valid_i; end end + endmodule diff --git a/hw/rtl/noise/cam_write_noise.sv b/hw/rtl/noise/cam_write_noise.sv index 7897539..252cf8d 100644 --- a/hw/rtl/noise/cam_write_noise.sv +++ b/hw/rtl/noise/cam_write_noise.sv @@ -5,7 +5,6 @@ module cam_write_noise #( parameter bit WRITE_NOISE_EN = 1'b1, parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_DEN = 100, - parameter int WRITE_NOISE_BITS = 8, parameter logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D ) ( input logic clk, @@ -18,30 +17,46 @@ module cam_write_noise #( output logic [(`ROW_BITS)-1:0] core_wr_row, output logic [(`HASH_BITS)-1:0] core_wr_hash ); - logic pending_q; - logic [(`ROW_BITS)-1:0] row_q; - logic [(`HASH_BITS)-1:0] hash_q; - logic [127:0] random_num; + + localparam int PROB_BITS = 8; + localparam int SAMPLE_RANGE = 1 << PROB_BITS; + localparam int WRITE_NOISE_THRESHOLD_RAW = + (WRITE_NOISE_RATE_NUM * SAMPLE_RANGE) / WRITE_NOISE_RATE_DEN; + localparam int WRITE_NOISE_THRESHOLD = + (WRITE_NOISE_THRESHOLD_RAW > (SAMPLE_RANGE - 1)) ? + (SAMPLE_RANGE - 1) : WRITE_NOISE_THRESHOLD_RAW; + + wire noise_active = WRITE_NOISE_EN && (WRITE_NOISE_RATE_NUM > 0) && (WRITE_NOISE_THRESHOLD > 0); + + typedef enum logic [1:0] { + STATE_IDLE, + STATE_WAIT_MASK + } state_t; + + state_t state_q; + logic mask_start_q; + logic mask_busy; + logic mask_done; logic [(`HASH_BITS)-1:0] flip_mask; + logic [(`ROW_BITS)-1:0] row_q; + logic [(`HASH_BITS)-1:0] hash_q; - assign wr_ready = !pending_q; + assign wr_ready = (state_q == STATE_IDLE); - random128 u_random_write ( - .clk (clk), - .rst_n (rst_n), - .enable(wr_valid && wr_ready && WRITE_NOISE_EN && (WRITE_NOISE_RATE_NUM > 0)), - .seed ({WRITE_NOISE_SEED, WRITE_NOISE_SEED}), - .out (random_num) - ); - - noise_mask_grouped #( + noise_mask_bernoulli #( .HASH_BITS (`HASH_BITS), - .NOISE_BITS (WRITE_NOISE_BITS), - .NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), - .NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN) - ) u_mask ( - .random_i(random_num), - .mask_o (flip_mask) + .PROB_BITS (PROB_BITS), + .PRNG_WORDS (2), + .BITS_PER_CYCLE (32), + .SEED (WRITE_NOISE_SEED) + ) u_bernoulli_mask ( + .clk (clk), + .rst_n (rst_n), + .start_i (mask_start_q), + .threshold_i (PROB_BITS'(WRITE_NOISE_THRESHOLD)), + .busy_o (mask_busy), + .done_o (mask_done), + .mask_o (flip_mask) ); `ifndef SYNTHESIS @@ -52,26 +67,47 @@ module cam_write_noise #( always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin - pending_q <= 1'b0; - row_q <= '0; - hash_q <= '0; + state_q <= STATE_IDLE; + mask_start_q <= 1'b0; + row_q <= '0; + hash_q <= '0; core_wr_valid <= 1'b0; - core_wr_row <= '0; - core_wr_hash <= '0; + core_wr_row <= '0; + core_wr_hash <= '0; end else begin - core_wr_valid <= pending_q; - core_wr_row <= row_q; - if (WRITE_NOISE_EN && (WRITE_NOISE_RATE_NUM > 0)) begin - core_wr_hash <= hash_q ^ flip_mask; - end else begin - core_wr_hash <= hash_q; - end + core_wr_valid <= 1'b0; + mask_start_q <= 1'b0; - pending_q <= wr_valid && wr_ready; - if (wr_valid && wr_ready) begin - row_q <= wr_row; - hash_q <= wr_hash; - end + unique case (state_q) + STATE_IDLE: begin + if (wr_valid && wr_ready) begin + row_q <= wr_row; + hash_q <= wr_hash; + if (noise_active) begin + mask_start_q <= 1'b1; + state_q <= STATE_WAIT_MASK; + end else begin + // Noise inactive: pass through immediately (one-cycle) + core_wr_valid <= 1'b1; + core_wr_row <= wr_row; + core_wr_hash <= wr_hash; + end + end + end + + STATE_WAIT_MASK: begin + if (mask_done) begin + core_wr_valid <= 1'b1; + core_wr_row <= row_q; + core_wr_hash <= hash_q ^ flip_mask; + state_q <= STATE_IDLE; + end + end + + default: begin + state_q <= STATE_IDLE; + end + endcase end end endmodule diff --git a/hw/rtl/noise/noise_mask_grouped.sv b/hw/rtl/noise/noise_mask_grouped.sv deleted file mode 100644 index 159fdb6..0000000 --- a/hw/rtl/noise/noise_mask_grouped.sv +++ /dev/null @@ -1,39 +0,0 @@ -`timescale 1ns / 1ps -`include "cam_params.svh" - -module noise_mask_grouped #( - parameter int HASH_BITS = `HASH_BITS, - parameter int NOISE_BITS = 8, - parameter int NOISE_RATE_NUM = 1, - parameter int NOISE_RATE_DEN = 100 -) ( - input logic [127:0] random_i, - output logic [HASH_BITS-1:0] mask_o -); - localparam int GROUP_BITS = HASH_BITS / NOISE_BITS; - localparam int BIT_INDEX_BITS = 6; - localparam int SAMPLE_BITS = 8; - localparam int GROUP_RAND_BITS = BIT_INDEX_BITS + SAMPLE_BITS; - localparam int SAMPLE_RANGE = 1 << SAMPLE_BITS; - localparam int THRESHOLD = (NOISE_RATE_NUM * SAMPLE_RANGE) / NOISE_RATE_DEN; - - `ifndef SYNTHESIS - initial begin - if (NOISE_BITS <= 0) $fatal(1, "NOISE_BITS must be > 0"); - if (HASH_BITS % NOISE_BITS != 0) $fatal(1, "HASH_BITS must be divisible by NOISE_BITS"); - if (GROUP_BITS != 64) $fatal(1, "GROUP_BITS must be 64 for 6-bit grouped noise"); - if (NOISE_BITS * GROUP_RAND_BITS > 128) $fatal(1, "NOISE_BITS consumes more than 128 random bits"); - if (NOISE_RATE_DEN <= 0) $fatal(1, "NOISE_RATE_DEN must be > 0"); - if (NOISE_RATE_NUM < 0 || NOISE_RATE_NUM > NOISE_RATE_DEN) $fatal(1, "NOISE_RATE_NUM out of range"); - end - `endif - - always_comb begin - mask_o = '0; - for (int i = 0; i < NOISE_BITS; i++) begin - if (random_i[i * GROUP_RAND_BITS + BIT_INDEX_BITS +: SAMPLE_BITS] < THRESHOLD) begin - mask_o[i * GROUP_BITS + random_i[i * GROUP_RAND_BITS +: BIT_INDEX_BITS]] = 1'b1; - end - end - end -endmodule diff --git a/hw/sim/benchmarks/retrieval/Makefile b/hw/sim/benchmarks/retrieval/Makefile index 7e77eec..5424acc 100644 --- a/hw/sim/benchmarks/retrieval/Makefile +++ b/hw/sim/benchmarks/retrieval/Makefile @@ -9,7 +9,6 @@ VERILOG_SOURCES := $(RTL_CAM_TOP) TOPK_K ?= 5 NUM_ROWS ?= 4096 WRITE_NOISE_EN ?= 0 -READ_NOISE_EN ?= 0 CAM_RETRIEVAL_DATASET ?= export CAM_RETRIEVAL_DATASET diff --git a/hw/sim/benchmarks/retrieval/test_retrieval_benchmark.py b/hw/sim/benchmarks/retrieval/test_retrieval_benchmark.py index 0cc8b2b..54bfed4 100644 --- a/hw/sim/benchmarks/retrieval/test_retrieval_benchmark.py +++ b/hw/sim/benchmarks/retrieval/test_retrieval_benchmark.py @@ -12,10 +12,8 @@ import numpy as np from cocotb.clock import Clock from model.ref_model import ( - lane_seed_128, match_topk, match_topk_from_scores, - score_rows_with_read_noise, ) from tests.top.utils import ( dut_hash_bits, @@ -199,13 +197,9 @@ def compute_metrics(topk_indices: list[int], row_labels: list[int], query_label: return precision, recall, f1 -def mode_from_params(write_noise_en: int, read_noise_en: int) -> str: - if write_noise_en and read_noise_en: - return "write_read_noise" +def mode_from_params(write_noise_en: int) -> str: if write_noise_en: return "write_noise" - if read_noise_en: - return "read_noise" return "no_noise" @@ -228,8 +222,8 @@ def write_outputs(out_dir: Path, result: dict) -> None: fieldnames = [ "run_id", "mode", "num_rows", "hash_bits", "lanes", "topk_k", - "write_noise_en", "read_noise_en", "write_noise_rate_num", - "write_noise_rate_den", "read_noise_rate_num", "read_noise_rate_den", + "write_noise_en", "write_noise_rate_num", + "write_noise_rate_den", "num_queries", "k", "macro_precision", "retrieval_recall", "macro_f1", "recall@k", "exact_match_rate", "status", ] @@ -245,11 +239,8 @@ def write_outputs(out_dir: Path, result: dict) -> None: "lanes": result["params"]["lanes"], "topk_k": result["params"]["topk_k"], "write_noise_en": result["params"]["write_noise_en"], - "read_noise_en": result["params"]["read_noise_en"], "write_noise_rate_num": result["params"]["write_noise_rate_num"], "write_noise_rate_den": result["params"]["write_noise_rate_den"], - "read_noise_rate_num": result["params"]["read_noise_rate_num"], - "read_noise_rate_den": result["params"]["read_noise_rate_den"], "num_queries": result["dataset"]["num_queries"], "k": int(k), "macro_precision": metrics["macro_precision"], @@ -293,13 +284,9 @@ async def cam_retrieval_benchmark(dut): hash_bits = dut_hash_bits(dut) lanes = dut_lanes(dut) write_noise_en = int(get_param(dut, "WRITE_NOISE_EN", 0) or 0) - read_noise_en = int(get_param(dut, "READ_NOISE_EN", 0) or 0) write_noise_rate_num = int(get_param(dut, "WRITE_NOISE_RATE_NUM", 0) or 0) write_noise_rate_den = int(get_param(dut, "WRITE_NOISE_RATE_DEN", 100) or 100) - read_noise_rate_num = int(get_param(dut, "READ_NOISE_RATE_NUM", 0) or 0) - read_noise_rate_den = int(get_param(dut, "READ_NOISE_RATE_DEN", 100) or 100) - read_noise_bits = int(get_param(dut, "READ_NOISE_BITS", 8) or 8) - mode = mode_from_params(write_noise_en, read_noise_en) + mode = mode_from_params(write_noise_en) if write_noise_en: raise AssertionError("First retrieval benchmark version only supports WRITE_NOISE_EN=0") @@ -315,7 +302,6 @@ async def cam_retrieval_benchmark(dut): await write_rows(dut, dataset.rows) accumulators = {k: MetricAccumulator() for k in BENCHMARK_KS} - read_lane_states = [lane_seed_128(0x6A09_E667_F3BC_C909, lane) for lane in range(lanes)] for query, query_label in zip(dataset.queries, dataset.query_labels): beats, _, _, _ = await query_topk_once(dut, query) @@ -324,15 +310,7 @@ async def cam_retrieval_benchmark(dut): dut_topk = [int(beat[1]) for beat in beats[: max(BENCHMARK_KS)]] - if read_noise_en: - scores, read_lane_states = score_rows_with_read_noise( - query, dataset.rows, lane_states=read_lane_states, - width=hash_bits, lanes=lanes, noise_bits=read_noise_bits, - rate_num=read_noise_rate_num, rate_den=read_noise_rate_den, - ) - golden_topk = match_topk_from_scores(scores, max(BENCHMARK_KS)) - else: - golden_topk, _ = match_topk(query, dataset.rows, width=hash_bits, k=max(BENCHMARK_KS)) + golden_topk, _ = match_topk(query, dataset.rows, width=hash_bits, k=max(BENCHMARK_KS)) for k in BENCHMARK_KS: precision, recall, f1 = compute_metrics(dut_topk, dataset.row_labels, query_label, k) @@ -352,11 +330,8 @@ async def cam_retrieval_benchmark(dut): "lanes": lanes, "topk_k": max(BENCHMARK_KS), "write_noise_en": write_noise_en, - "read_noise_en": read_noise_en, "write_noise_rate_num": write_noise_rate_num, "write_noise_rate_den": write_noise_rate_den, - "read_noise_rate_num": read_noise_rate_num, - "read_noise_rate_den": read_noise_rate_den, }, "dataset": { "num_classes": dataset.num_classes, diff --git a/hw/sim/mk/cocotb-common.mk b/hw/sim/mk/cocotb-common.mk index dec44d7..6acf071 100644 --- a/hw/sim/mk/cocotb-common.mk +++ b/hw/sim/mk/cocotb-common.mk @@ -37,11 +37,6 @@ COMPILE_ARGS += $(EXTRA_DEFINES) WRITE_NOISE_EN ?= $(NOISE_EN) WRITE_NOISE_RATE_NUM ?= $(NOISE_RATE_NUM) WRITE_NOISE_RATE_DEN ?= $(NOISE_RATE_DEN) -WRITE_NOISE_BITS ?= $(NOISE_BITS) -READ_NOISE_EN ?= $(NOISE_EN) -READ_NOISE_RATE_NUM ?= $(NOISE_RATE_NUM) -READ_NOISE_RATE_DEN ?= $(NOISE_RATE_DEN) -READ_NOISE_BITS ?= $(NOISE_BITS) ifneq ($(strip $(WRITE_NOISE_EN)),) COMPILE_ARGS += -GWRITE_NOISE_EN=$(WRITE_NOISE_EN) @@ -52,21 +47,6 @@ endif ifneq ($(strip $(WRITE_NOISE_RATE_DEN)),) COMPILE_ARGS += -GWRITE_NOISE_RATE_DEN=$(WRITE_NOISE_RATE_DEN) endif -ifneq ($(strip $(WRITE_NOISE_BITS)),) -COMPILE_ARGS += -GWRITE_NOISE_BITS=$(WRITE_NOISE_BITS) -endif -ifneq ($(strip $(READ_NOISE_EN)),) -COMPILE_ARGS += -GREAD_NOISE_EN=$(READ_NOISE_EN) -endif -ifneq ($(strip $(READ_NOISE_RATE_NUM)),) -COMPILE_ARGS += -GREAD_NOISE_RATE_NUM=$(READ_NOISE_RATE_NUM) -endif -ifneq ($(strip $(READ_NOISE_RATE_DEN)),) -COMPILE_ARGS += -GREAD_NOISE_RATE_DEN=$(READ_NOISE_RATE_DEN) -endif -ifneq ($(strip $(READ_NOISE_BITS)),) -COMPILE_ARGS += -GREAD_NOISE_BITS=$(READ_NOISE_BITS) -endif export PYTHONPATH := $(SIM_ROOT):$(PYTHONPATH) export QUIET ?= 1 diff --git a/hw/sim/mk/rtl-sources.mk b/hw/sim/mk/rtl-sources.mk index 6c1ae54..e65cd6d 100644 --- a/hw/sim/mk/rtl-sources.mk +++ b/hw/sim/mk/rtl-sources.mk @@ -4,10 +4,9 @@ endif RTL_RANDOM := $(RTL_ROOT)/random/random128.sv -RTL_NOISE_MASK := $(RTL_ROOT)/noise/noise_mask_grouped.sv RTL_BERNOULLI_NOISE_MASK := $(RTL_ROOT)/noise/noise_mask_bernoulli.sv $(RTL_RANDOM) -RTL_WRITE_NOISE := $(RTL_NOISE_MASK) $(RTL_RANDOM) $(RTL_ROOT)/noise/cam_write_noise.sv -RTL_READ_NOISE := $(RTL_NOISE_MASK) $(RTL_RANDOM) $(RTL_ROOT)/noise/cam_read_noise.sv +RTL_WRITE_NOISE := $(RTL_BERNOULLI_NOISE_MASK) $(RTL_ROOT)/noise/cam_write_noise.sv +RTL_READ_NOISE := $(RTL_ROOT)/noise/cam_read_noise.sv RTL_CAM_CORE_BANKED := $(RTL_ROOT)/core/cam_core_banked.sv RTL_MATCH_ENGINE := \ diff --git a/hw/sim/model/ref_model.py b/hw/sim/model/ref_model.py index 4ca6659..114b0f1 100644 --- a/hw/sim/model/ref_model.py +++ b/hw/sim/model/ref_model.py @@ -94,204 +94,6 @@ def xorshift128(state: int) -> int: return ((next_x << 96) | (next_y << 64) | (next_z << 32) | next_w) & mask128 -def generate_write_flip_mask( - prng_state: int, - hash_bits: int, - noise_bits: int, - rate_num: int, - rate_den: int, -) -> tuple[int, int]: - """Generate one write-noise flip mask using one xorshift128 step.""" - assert hash_bits % noise_bits == 0 - group_bits = hash_bits // noise_bits - bit_index_bits = 6 - sample_bits = 8 - group_random_bits = bit_index_bits + sample_bits - assert group_bits == 64 - assert noise_bits * group_random_bits <= 128 - - sample_range = 1 << sample_bits - threshold = (rate_num * sample_range) // rate_den - - state = xorshift128(prng_state) - mask = 0 - for group_idx in range(noise_bits): - group_rand = (state >> (group_idx * group_random_bits)) & ((1 << group_random_bits) - 1) - bit_idx = group_rand & ((1 << bit_index_bits) - 1) - sample = (group_rand >> bit_index_bits) & (sample_range - 1) - if sample < threshold: - mask |= 1 << (group_idx * group_bits + bit_idx) - - return mask, state - - -def generate_grouped_flip_mask( - *, - random_value: int, - hash_bits: int, - noise_bits: int, - rate_num: int, - rate_den: int, -) -> int: - """Generate a grouped flip mask from one 128-bit value. - - This is the shared write/read noise model: 8 default 64-bit groups, one - candidate flip per group, 6-bit bit index and 8-bit threshold sample. - It is not independent Bernoulli sampling over all 512 bits. - """ - assert noise_bits > 0 - assert hash_bits % noise_bits == 0 - group_bits = hash_bits // noise_bits - bit_index_bits = 6 - sample_bits = 8 - group_random_bits = bit_index_bits + sample_bits - assert group_bits == 64 - assert noise_bits * group_random_bits <= 128 - assert rate_den > 0 - assert 0 <= rate_num <= rate_den - - sample_range = 1 << sample_bits - threshold = (rate_num * sample_range) // rate_den - mask = 0 - - for group_idx in range(noise_bits): - group_rand = (random_value >> (group_idx * group_random_bits)) & ((1 << group_random_bits) - 1) - bit_idx = group_rand & ((1 << bit_index_bits) - 1) - sample = (group_rand >> bit_index_bits) & (sample_range - 1) - if sample < threshold: - mask |= 1 << (group_idx * group_bits + bit_idx) - - return mask - - -def lane_seed_128(seed: int, lane: int) -> int: - """Derive a nonzero 128-bit lane seed matching the RTL salt convention.""" - mask128 = (1 << 128) - 1 - salt = ((lane + 1) * 0x9E37_79B9_7F4A_7C15) & ((1 << 64) - 1) - mixed64 = (int(seed) ^ salt) & ((1 << 64) - 1) - state = ((mixed64 << 64) | mixed64) & mask128 - assert state != 0 - return state - - -def generate_read_lane_masks( - lane_states: list[int], - *, - hash_bits: int, - noise_bits: int, - rate_num: int, - rate_den: int, - lane_valid: list[bool], -) -> tuple[list[int], list[int]]: - """Advance valid lane PRNG states once and return one mask per lane.""" - next_states: list[int] = [] - masks: list[int] = [] - - for lane, state in enumerate(lane_states): - if lane_valid[lane]: - next_state = xorshift128(state) - mask = generate_grouped_flip_mask( - random_value=next_state, - hash_bits=hash_bits, - noise_bits=noise_bits, - rate_num=rate_num, - rate_den=rate_den, - ) - else: - next_state = state - mask = 0 - next_states.append(next_state) - masks.append(mask) - - return masks, next_states - - -def score_rows_with_read_noise( - query: int, - rows: Sequence[int], - *, - lane_states: Sequence[int], - width: int = 512, - lanes: int = 8, - noise_bits: int = 8, - rate_num: int = 1, - rate_den: int = 100, -) -> tuple[np.ndarray, list[int]]: - """Score one query with read noise and return updated lane PRNG states. - - Unlike match_top1_with_read_noise(), this helper is stateful across calls: - callers pass current lane states in and receive the next states back. - This matches a DUT that is reset once, then serves multiple queries. - """ - assert lanes > 0 - assert len(rows) % lanes == 0 - assert len(lane_states) == lanes - - scores = np.zeros(len(rows), dtype=np.int32) - next_lane_states = [int(state) for state in lane_states] - - for base in range(0, len(rows), lanes): - lane_valid = [True] * lanes - masks, next_lane_states = generate_read_lane_masks( - next_lane_states, - hash_bits=width, - noise_bits=noise_bits, - rate_num=rate_num, - rate_den=rate_den, - lane_valid=lane_valid, - ) - - for lane in range(lanes): - row_idx = base + lane - noisy_row = int(rows[row_idx]) ^ int(masks[lane]) - scores[row_idx] = xnor_popcount_score(int(query), noisy_row, width) - - return scores, next_lane_states - - -def match_top1_with_read_noise( - query: int, - rows: Sequence[int], - *, - width: int = 512, - lanes: int = 8, - noise_bits: int = 8, - rate_num: int = 1, - rate_den: int = 100, - seed: int = 0x6A09_E667_F3BC_C909, -) -> MatchResult: - """Top-1 matching with dynamic read noise, one query in flight.""" - assert lanes > 0 - assert len(rows) % lanes == 0 - - scores = np.zeros(len(rows), dtype=np.int32) - best_index = 0 - best_score = -1 - lane_states = [lane_seed_128(seed, lane) for lane in range(lanes)] - - for base in range(0, len(rows), lanes): - lane_valid = [True] * lanes - masks, lane_states = generate_read_lane_masks( - lane_states, - hash_bits=width, - noise_bits=noise_bits, - rate_num=rate_num, - rate_den=rate_den, - lane_valid=lane_valid, - ) - - for lane in range(lanes): - row_idx = base + lane - noisy_row = int(rows[row_idx]) ^ masks[lane] - score = xnor_popcount_score(int(query), noisy_row, width) - scores[row_idx] = score - if score > best_score: - best_score = score - best_index = row_idx - - return MatchResult(top1_index=int(best_index), top1_score=int(best_score), scores=scores) - - def random_hashes( rng: np.random.Generator, n: int, diff --git a/hw/sim/scripts/sweep_noise.py b/hw/sim/scripts/sweep_noise.py index 33135f6..01bc9af 100644 --- a/hw/sim/scripts/sweep_noise.py +++ b/hw/sim/scripts/sweep_noise.py @@ -16,7 +16,6 @@ if str(SIM_ROOT) not in sys.path: import numpy as np from model.ref_model import ( - generate_write_flip_mask, match_top1, random_hashes, ) @@ -31,20 +30,12 @@ def apply_write_noise( noise_bits: int = 8, seed: int = 0, ) -> list[int]: - """Apply write-noise flip masks to every row, returning noisy copies. + """No-op: write-noise flip masks are now generated by Bernoulli RTL only. - *seed* is a 64-bit value (RTL NOISE_SEED). It is duplicated to form - the 128-bit xorshift initial state: {seed, seed}. + The sweep now measures top-1 stability of pure matching over queries, + since noise is applied at RTL write time, not in the Python model. """ - noisy: list[int] = [] - state = (seed << 64) | seed - mask_w = (1 << width) - 1 - for row in rows: - flip, state = generate_write_flip_mask( - state, width, noise_bits, rate_num, rate_den - ) - noisy.append((row ^ flip) & mask_w) - return noisy + return list(rows) def main() -> None: diff --git a/hw/sim/tests/model/test_ref_model_noise.py b/hw/sim/tests/model/test_ref_model_noise.py index 1afb087..6741fbc 100644 --- a/hw/sim/tests/model/test_ref_model_noise.py +++ b/hw/sim/tests/model/test_ref_model_noise.py @@ -1,94 +1,31 @@ # -*- coding: utf-8 -*- """ -参考模型（ref_model）的纯 Python 单元测试。 +参考模型（ref_model）的纯 Python 单元测试 — Phase 2 cleaned. 本文件不涉及任何 RTL / Verilator 仿真，仅验证 Python 参考模型的正确性。 -所有 RTL-vs-模型 的对比测试（如顶层 test_cam_basic.py）都依赖此参考模型， -因此这里是整个测试体系的「基石」——参考模型如果有 bug，所有对比测试都将失效。 +Phase 2 后只保留 pure matching 函数；所有 grouped/read-noise helpers 已删除。 测试覆盖： - 1. 分组翻转掩码 — 完全速率 (rate=1/1) 的正确位翻转模式 - 2. 分组翻转掩码 — 零速率 (rate=0/100) 不应产生任何翻转 - 3. 评分函数语义 — 确认是「匹配位数」而非「汉明距离」 - 4. 读取噪声模型 — 相同输入 + 相同种子 = 可复现结果 + 1. XNOR 评分语义 — 确认是「匹配位数」而非「汉明距离」 + 2. Top-1 matching — 纯匹配，正确选出最高分索引 + 3. Top-K matching — 返回排序后的行索引列表 + 4. Top-K 排序规则 — 分数降序、平局行号升序 + 5. Top-K k 超过行数时 clamp """ + from __future__ import annotations from model.ref_model import ( - generate_grouped_flip_mask, - match_top1_with_read_noise, + match_top1, + match_topk, + match_topk_from_scores, xnor_popcount_score, ) +import numpy as np # ============================================================================== -# 测试 1：完全速率下的分组翻转掩码生成 -# ============================================================================== - - -def test_grouped_flip_mask_full_rate_one_bit_per_64_bit_group(): - """ - 验证 generate_grouped_flip_mask 在 rate_num=1, rate_den=1 时的行为。 - - 背景： - - CAM 的 write noise 模块将 512-bit 哈希按 64-bit 分组，每组最多翻转 1 位。 - - random_value 的位域含义（每 group 14 bits）： - bits [5:0] → sample（未使用） - bits [13:6] → bit_idx（选择该组内翻转哪一位） - - 本测试： - - 构造一个 random_value，使每个 group 的 bit_idx = group+1 - - 断言生成的 mask 恰好有 8 个位被置位（每 group 一个） - - 断言每个被翻转的位位置与预期一致 - """ - random_value = 0 - for group in range(8): - bit_idx = group + 1 - sample = 0 - random_value |= bit_idx << (group * 14) - random_value |= sample << (group * 14 + 6) - - mask = generate_grouped_flip_mask( - random_value=random_value, - hash_bits=512, # 8 组 × 64 bits/组 - noise_bits=8, # 每组的 bit_idx 位宽 - rate_num=1, # 分子 = 1 - rate_den=1, # 分母 = 1 → 100% 概率，每组都翻转 - ) - - # 预期：每组的 bit_idx 位被翻转 - expected = 0 - for group in range(8): - expected |= 1 << (group * 64 + group + 1) - - assert mask == expected - assert mask.bit_count() == 8 # 恰好 8 位被翻转（每组一位） - - -# ============================================================================== -# 测试 2：零速率下不应产生任何翻转 -# ============================================================================== - - -def test_grouped_flip_mask_zero_rate_no_flips(): - """ - 验证 rate_num=0 时，无论 random_value 为何值，mask 都应为 0。 - - 这是写入噪声的「零噪声」配置边界测试—— - 确保 RTL 参数 WRITE_NOISE_RATE_NUM=0 能真正关闭噪声注入。 - """ - mask = generate_grouped_flip_mask( - random_value=(1 << 128) - 1, # 全 1 的 random_value - hash_bits=512, - noise_bits=8, - rate_num=0, # 分子 = 0 → 翻转概率为 0 - rate_den=100, - ) - assert mask == 0 # mask 必须全 0，一个位都不翻 - - -# ============================================================================== -# 测试 3：评分函数语义 — 确认是「XNOR 匹配位数」而非「汉明距离」 +# 测试 1：评分函数语义 — 确认是「XNOR 匹配位数」而非「汉明距离」 # ============================================================================== @@ -114,64 +51,27 @@ def test_score_is_bit_match_popcount_not_hamming_distance(): # ============================================================================== -# 测试 4：读取噪声模型的可复现性（确定性种子） +# 测试 2：Top-1 matching # ============================================================================== -def test_read_noise_model_is_reproducible_after_reset_seed(): - """ - 验证 match_top1_with_read_noise 在相同参数下产生相同结果。 - - 为什么这个测试至关重要： - - RTL 中的 read noise PRNG 使用固定种子 (0x6A09E667F3BCC909) - - 参考模型必须使用相同的种子来复现 RTL 的噪声行为 - - 如果两次调用结果不同，说明模型存在非确定性 bug - （如未重置 PRNG 状态、或使用了非确定性随机源） - - 测试数据： - - 8 行不同模式的 512-bit 哈希（全0、全1、稀疏值） - - 噪声配置：rate=1%, lanes=8, noise_bits=8 - """ - rows = [0, (1 << 512) - 1, 0x1234, 0x5678, 0x9ABC, 0xDEF0, 0x1357, 0x2468] - query = rows[2] - kwargs = dict( - query=query, - rows=rows, - width=512, - lanes=8, - noise_bits=8, - rate_num=1, - rate_den=100, - seed=0x6A09_E667_F3BC_C909, - ) - - first = match_top1_with_read_noise(**kwargs) - second = match_top1_with_read_noise(**kwargs) - - # 两次调用的 Top-1 结果和分数数组必须完全一致 - assert first.top1_index == second.top1_index - assert first.top1_score == second.top1_score - assert first.scores.tolist() == second.scores.tolist() +def test_match_top1_selects_highest_xnor_score_with_row_index_tiebreak(): + """Top-1 应选出 XNOR 分最高的行；平局时选最小行号。""" + rows = [0b0000, 0b1111, 0b0011, 0b0101] + query = 0b0000 + result = match_top1(query, rows, width=4) + assert result.top1_index == 0 + assert result.top1_score == 4 + assert result.scores.tolist() == [4, 0, 2, 2] # ============================================================================== -# 测试 5：Top-K 排序 — 分数降序、平局行号升序 +# 测试 3：Top-K matching # ============================================================================== -def test_match_topk_from_scores_uses_score_desc_then_row_asc(): - """Top-K 排序规则：分数越大越优先；分数相同时行号越小越优先。""" - from model.ref_model import match_topk_from_scores - import numpy as np - - scores = np.array([7, 9, 9, 2, 7], dtype=np.int32) - assert match_topk_from_scores(scores, 4) == [1, 2, 0, 4] - - def test_match_topk_scores_rows_by_xnor_popcount(): """match_topk 通过 xnor_popcount 计算分数，返回排序后的行索引和分数数组。""" - from model.ref_model import match_topk - rows = [0b0000, 0b1111, 0b0011, 0b0101] query = 0b0000 indices, scores = match_topk(query, rows, width=4, k=3) @@ -179,43 +79,24 @@ def test_match_topk_scores_rows_by_xnor_popcount(): assert indices == [0, 2, 3] +# ============================================================================== +# 测试 4：Top-K 排序 — 分数降序、平局行号升序 +# ============================================================================== + + +def test_match_topk_from_scores_uses_score_desc_then_row_asc(): + """Top-K 排序规则：分数越大越优先；分数相同时行号越小越优先。""" + scores = np.array([7, 9, 9, 2, 7], dtype=np.int32) + assert match_topk_from_scores(scores, 4) == [1, 2, 0, 4] + + +# ============================================================================== +# 测试 5：Top-K k 超过行数时 clamp +# ============================================================================== + + def test_match_topk_clamps_k_to_row_count(): """当 k 超过实际行数时，返回所有行（按排序）。""" - from model.ref_model import match_topk - indices, scores = match_topk(0, [0, 1], width=1, k=5) assert scores.tolist() == [1, 0] assert indices == [0, 1] - - -# ============================================================================== -# 测试 6：读取噪声 stateful 评分助手的跨查询状态推进 -# ============================================================================== - - -def test_score_rows_with_read_noise_stateful_across_queries(): - """score_rows_with_read_noise 在多次调用间正确推进 lane PRNG 状态。 - - 两次调用使用相同的 rows/query 和零噪声率： - - 分数应一致（无噪声翻转） - - 但 lane states 应该变化（PRNG 已推进） - """ - from model.ref_model import score_rows_with_read_noise - - rows = [0, 0, 0, 0] - query = 0 - lane_states = [1, 2] - - scores_1, next_states_1 = score_rows_with_read_noise( - query, rows, lane_states=lane_states, width=128, lanes=2, - noise_bits=2, rate_num=0, rate_den=100, - ) - scores_2, next_states_2 = score_rows_with_read_noise( - query, rows, lane_states=next_states_1, width=128, lanes=2, - noise_bits=2, rate_num=0, rate_den=100, - ) - - assert scores_1.tolist() == [128, 128, 128, 128] - assert scores_2.tolist() == [128, 128, 128, 128] - assert next_states_1 != lane_states - assert next_states_2 != next_states_1 diff --git a/hw/sim/tests/modules/cam_read_noise/Makefile b/hw/sim/tests/modules/cam_read_noise/Makefile index 8eb63dd..a80b252 100644 --- a/hw/sim/tests/modules/cam_read_noise/Makefile +++ b/hw/sim/tests/modules/cam_read_noise/Makefile @@ -7,9 +7,5 @@ COCOTB_TEST_MODULES := tests.modules.cam_read_noise.test_cam_read_noise VERILOG_SOURCES := $(RTL_READ_NOISE) HASH_BITS ?= 512 -READ_NOISE_EN ?= 0 -READ_NOISE_RATE_NUM ?= 0 -READ_NOISE_RATE_DEN ?= 100 -READ_NOISE_BITS ?= $(shell echo $$(( $(HASH_BITS) / 64 ))) include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/modules/cam_read_noise/test_cam_read_noise.py b/hw/sim/tests/modules/cam_read_noise/test_cam_read_noise.py index f171623..8826f54 100644 --- a/hw/sim/tests/modules/cam_read_noise/test_cam_read_noise.py +++ b/hw/sim/tests/modules/cam_read_noise/test_cam_read_noise.py @@ -2,7 +2,7 @@ from __future__ import annotations import cocotb from cocotb.clock import Clock -from cocotb.triggers import RisingEdge +from cocotb.triggers import RisingEdge, Timer async def reset_read_noise(dut): @@ -38,11 +38,45 @@ async def read_noise_disabled_forwards_hashes_after_one_stage(dut): dut.row_ids_i.value = rows dut.lane_valid_i.value = all_lanes_valid dut.valid_i.value = 1 - await RisingEdge(dut.clk) + await Timer(1, unit="step") + await RisingEdge(dut.clk) # valid_o ← valid_i=1 internally + await Timer(1, unit="step") dut.valid_i.value = 0 - await RisingEdge(dut.clk) - await RisingEdge(dut.clk) + # One-stage pass-through: valid_o holds the latched value for this cycle + assert int(dut.valid_o.value) == 1 + assert int(dut.hashes_noisy_o.value) == hashes + assert int(dut.row_ids_o.value) == rows + assert int(dut.lane_valid_o.value) == all_lanes_valid + + +@cocotb.test() +async def read_noise_enabled_still_forwards_hashes_unmodified(dut): + """With READ_NOISE_EN=1, the pass-through still forwards hashes unmodified.""" + cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) + await reset_read_noise(dut) + + LANES = len(dut.lane_valid_i) + ROW_BITS = len(dut.row_ids_i) // LANES + HASH_BITS_PER_LANE = len(dut.hashes_i) // LANES + all_lanes_valid = (1 << LANES) - 1 + + hashes = 0 + rows = 0 + for lane in range(LANES): + hashes |= (lane + 0x55) << (lane * HASH_BITS_PER_LANE) + rows |= lane << (lane * ROW_BITS) + + dut.hashes_i.value = hashes + dut.row_ids_i.value = rows + dut.lane_valid_i.value = all_lanes_valid + dut.valid_i.value = 1 + await Timer(1, unit="step") + await RisingEdge(dut.clk) # valid_o ← valid_i=1 internally + await Timer(1, unit="step") + dut.valid_i.value = 0 + + # One-stage pass-through: valid_o holds latched value from previous cycle assert int(dut.valid_o.value) == 1 assert int(dut.hashes_noisy_o.value) == hashes assert int(dut.row_ids_o.value) == rows diff --git a/hw/sim/tests/modules/cam_write_noise/Makefile b/hw/sim/tests/modules/cam_write_noise/Makefile index e3ae76e..2a915e4 100644 --- a/hw/sim/tests/modules/cam_write_noise/Makefile +++ b/hw/sim/tests/modules/cam_write_noise/Makefile @@ -10,6 +10,4 @@ HASH_BITS ?= 512 WRITE_NOISE_EN ?= 1 WRITE_NOISE_RATE_NUM ?= 1 WRITE_NOISE_RATE_DEN ?= 100 -WRITE_NOISE_BITS ?= $(shell echo $$(( $(HASH_BITS) / 64 ))) - include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/modules/cam_write_noise/test_cam_write_noise.py b/hw/sim/tests/modules/cam_write_noise/test_cam_write_noise.py index 0b635a8..531d8fc 100644 --- a/hw/sim/tests/modules/cam_write_noise/test_cam_write_noise.py +++ b/hw/sim/tests/modules/cam_write_noise/test_cam_write_noise.py @@ -2,8 +2,32 @@ from __future__ import annotations import cocotb from cocotb.clock import Clock -from cocotb.triggers import RisingEdge -from model.ref_model import generate_write_flip_mask +from cocotb.triggers import RisingEdge, Timer + +# Bernoulli: 1 PRIME + 16 RUN = 17 cycles internal +# + 1 cycle for mask_start propagation + 1 cycle for core_wr_valid output = 19 +DEFAULT_WRITE_NOISE_LATENCY = 19 + + +async def pulse_write(dut, row: int, value: int): + dut.wr_row.value = row + dut.wr_hash.value = value + dut.wr_valid.value = 1 + await Timer(1, unit="step") + assert int(dut.wr_ready.value) == 1 + await RisingEdge(dut.clk) + await Timer(1, unit="step") + dut.wr_valid.value = 0 + + +async def wait_core_write(dut, max_cycles: int = 128) -> int: + cycles = 0 + while int(dut.core_wr_valid.value) == 0: + assert cycles < max_cycles, "timed out waiting for core_wr_valid" + await RisingEdge(dut.clk) + await Timer(1, unit="step") + cycles += 1 + return cycles async def reset_write_noise(dut): @@ -19,23 +43,52 @@ async def reset_write_noise(dut): @cocotb.test() -async def write_noise_outputs_grouped_noisy_hash(dut): +async def write_noise_enabled_applies_bernoulli_mask_after_generation(dut): + """Noise active: FSM enters WAIT_MASK, core_wr_hash deterministic across reset.""" cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) await reset_write_noise(dut) - value = 0x123456789ABCDEF - dut.wr_row.value = 3 - dut.wr_hash.value = value - dut.wr_valid.value = 1 + value = (1 << 512) - 1 # all-ones: even low-rate Bernoulli may flip some bits + await pulse_write(dut, row=3, value=value) + await Timer(1, unit="step") + assert int(dut.wr_ready.value) == 0 + + cycles = await wait_core_write(dut) + assert cycles == DEFAULT_WRITE_NOISE_LATENCY + + assert int(dut.core_wr_row.value) == 3 + hash_after_first = int(dut.core_wr_hash.value) + await RisingEdge(dut.clk) + await Timer(1, unit="step") + assert int(dut.core_wr_valid.value) == 0 + assert int(dut.wr_ready.value) == 1 + + # Deterministic across reset: same seed → same mask → same noisy hash + await reset_write_noise(dut) + await pulse_write(dut, row=3, value=value) + await wait_core_write(dut) + assert int(dut.core_wr_hash.value) == hash_after_first + + +@cocotb.test() +async def write_noise_backpressures_second_write_until_done(dut): + cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) + await reset_write_noise(dut) + + await pulse_write(dut, row=1, value=0xAA55) + + dut.wr_row.value = 2 + dut.wr_hash.value = 0x55AA + dut.wr_valid.value = 1 + await Timer(1, unit="step") + for _ in range(4): + assert int(dut.wr_ready.value) == 0 + assert int(dut.core_wr_valid.value) == 0 + await RisingEdge(dut.clk) + await Timer(1, unit="step") dut.wr_valid.value = 0 - while int(dut.core_wr_valid.value) == 0: - await RisingEdge(dut.clk) - - seed = 0xB504_F32D_B504_F32D - hash_bits = len(dut.wr_hash) - noise_bits = hash_bits // 64 - flip, _ = generate_write_flip_mask((seed << 64) | seed, hash_bits, noise_bits, 1, 100) - assert int(dut.core_wr_row.value) == 3 - assert int(dut.core_wr_hash.value) == (value ^ flip) + cycles = await wait_core_write(dut) + assert cycles == DEFAULT_WRITE_NOISE_LATENCY - 4 # 19 - 4 = 15 + assert int(dut.core_wr_row.value) == 1 diff --git a/hw/sim/tests/perf/Makefile b/hw/sim/tests/perf/Makefile index cbdbd3b..0c915ff 100644 --- a/hw/sim/tests/perf/Makefile +++ b/hw/sim/tests/perf/Makefile @@ -8,8 +8,5 @@ VERILOG_SOURCES := $(RTL_CAM_TOP) HASH_BITS ?= 512 WRITE_NOISE_EN := 0 -READ_NOISE_EN := 0 -WRITE_NOISE_BITS := $(shell echo $$(( $(HASH_BITS) / 64 ))) -READ_NOISE_BITS := $(shell echo $$(( $(HASH_BITS) / 64 ))) include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/perf/test_cam_perf.py b/hw/sim/tests/perf/test_cam_perf.py index 5eaba87..0826939 100644 --- a/hw/sim/tests/perf/test_cam_perf.py +++ b/hw/sim/tests/perf/test_cam_perf.py @@ -243,7 +243,6 @@ async def cam_perf_benchmark(dut): hash_bits = dut_hash_bits(dut) lanes = dut_lanes(dut) write_noise_en = _get_param(dut, "WRITE_NOISE_EN", 1) - read_noise_en = _get_param(dut, "READ_NOISE_EN", 0) # ── Deterministic query ───────────────────────────────────────────── query_hash = 0xAA55_AA55_AA55_AA55_AA55_AA55_AA55_AA55 @@ -271,7 +270,7 @@ async def cam_perf_benchmark(dut): ) # ── Correctness assertions (conditional on noise state) ───────────── - if not write_noise_en and not read_noise_en: + if not write_noise_en: # Without noise: stored hash at row 0 == query_hash → exact match. assert top1_index == 0, ( f"Noise disabled: expected top1_index=0 (exact match), got " @@ -282,7 +281,7 @@ async def cam_perf_benchmark(dut): f"{top1_score}" ) else: - # With noise: write/read flip masks may corrupt stored values, so + # With noise: write flip masks may corrupt stored values, so # we cannot reliably assert the exact match. Instead, confirm a # valid non-zero score was produced (the match engine ran). assert top1_score > 0, ( @@ -290,10 +289,10 @@ async def cam_perf_benchmark(dut): "Match engine returned invalid result." ) dut._log.info( - "Noise enabled (WRITE_NOISE_EN=%s, READ_NOISE_EN=%s) — " + "Noise enabled (WRITE_NOISE_EN=%s) — " "skipping exact top1_index/top1_score assertion. " "top1_index=%d top1_score=%d", - write_noise_en, read_noise_en, top1_index, top1_score, + write_noise_en, top1_index, top1_score, ) # ── Machine-readable performance marker ───────────────────────────── diff --git a/hw/sim/tests/top/no_noise/Makefile b/hw/sim/tests/top/no_noise/Makefile index ad64f98..4efcb36 100644 --- a/hw/sim/tests/top/no_noise/Makefile +++ b/hw/sim/tests/top/no_noise/Makefile @@ -8,6 +8,5 @@ VERILOG_SOURCES := $(RTL_CAM_TOP) # 禁用所有噪声模块 WRITE_NOISE_EN := 0 -READ_NOISE_EN := 0 include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/top/no_noise/test_no_noise.py b/hw/sim/tests/top/no_noise/test_no_noise.py index c7986f9..d4475ef 100644 --- a/hw/sim/tests/top/no_noise/test_no_noise.py +++ b/hw/sim/tests/top/no_noise/test_no_noise.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- """ -CAM 顶层（cam_top）no_noise 配置集成测试（WRITE_NOISE_EN=0, READ_NOISE_EN=0）。 +CAM 顶层（cam_top）no_noise 配置集成测试（WRITE_NOISE_EN=0）。 所有噪声模块禁用，验证 CAM 在无噪声下的标准行为。 @@ -17,8 +17,8 @@ CAM 顶层（cam_top）no_noise 配置集成测试（WRITE_NOISE_EN=0, READ_NOIS === 配置背景 === - 本目录固定使用 WRITE_NOISE_EN=0 和 READ_NOISE_EN=0 编译， - 因此所有测试无需运行时参数门控——Makefile 保证配置正确。 + 本目录固定使用 WRITE_NOISE_EN=0 编译， + 因此所有测试无需运行时参数门控——Makefile 保证配置正确。 """ from __future__ import annotations @@ -62,7 +62,7 @@ async def compile_includes_grouped_noise_helper(dut): # ═══════════════════════════════════════════════════════════════════════════════ -# 测试 A：基线（WRITE_NOISE_EN=0, READ_NOISE_EN=0） +# 测试 A：基线（WRITE_NOISE_EN=0） # ── 验证写+查在噪声关闭时与旧 CAM 行为完全一致 # ═══════════════════════════════════════════════════════════════════════════════ diff --git a/hw/sim/tests/top/read_noise/Makefile b/hw/sim/tests/top/read_noise/Makefile index aacad2a..c35c628 100644 --- a/hw/sim/tests/top/read_noise/Makefile +++ b/hw/sim/tests/top/read_noise/Makefile @@ -6,10 +6,7 @@ TOPLEVEL := cam_top COCOTB_TEST_MODULES := tests.top.read_noise.test_read_noise VERILOG_SOURCES := $(RTL_CAM_TOP) -# 读取噪声开启，写入噪声默认关闭 -READ_NOISE_EN := 1 -READ_NOISE_RATE_NUM := 1 -READ_NOISE_RATE_DEN := 100 +# 读取噪声开启（Phase 2 后为 pass-through），写入噪声默认关闭 WRITE_NOISE_EN := 0 include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/top/read_noise/test_read_noise.py b/hw/sim/tests/top/read_noise/test_read_noise.py index 199f345..dcdcecd 100644 --- a/hw/sim/tests/top/read_noise/test_read_noise.py +++ b/hw/sim/tests/top/read_noise/test_read_noise.py @@ -1,27 +1,9 @@ # -*- coding: utf-8 -*- """ -CAM 读取噪声（read_noise）集成测试。 +CAM 读取路径 pass-through 集成测试 — Phase 2 cleaned. -本文件针对 READ_NOISE_EN=1 的编译配置，验证 RTL 的读取噪声行为 -与 Python 参考模型（ref_model）一致。 - -=== 测试内容 === - - read_noise_model_match — 读取噪声模型匹配： - 写入原始哈希，预测含写入噪声（如果 WRITE_NOISE_EN=1）的存储值， - 再用 match_top1_with_read_noise 计算含读取噪声的期望结果， - 与 RTL 实际 Top-1 进行比对。 - -=== 架构背景 === - - CAM 硬件由以下流水线组成： - Write Noise → Banked Core Storage → Read Noise → Match Engine Pipeline - ↓ - Top-K Tracker → Result Serializer - - 本测试覆盖的是 Read Noise → Match Engine 段。 - 写入噪声（WRITE_NOISE_EN）通过 Makefile 的 test-with-write-noise 子目标 - 启用，测试代码内部已兼容两种配置。 +Read noise 已退休；cam_read_noise 是纯 pass-through。 +本测试验证查询返回的 scores 与 pure matching 一致。 """ from __future__ import annotations @@ -31,83 +13,40 @@ import numpy as np from cocotb.clock import Clock from cocotb.triggers import RisingEdge from model.ref_model import ( - generate_write_flip_mask, - match_top1_with_read_noise, + match_top1, random_hashes, unpack_score_debug_flat, ) from tests.top.utils import ( + collect_topk, dut_hash_bits, dut_lanes, dut_num_rows, get_param, query_once, + query_topk_once, reset_dut, + write_row, write_rows, ) -# ═══════════════════════════════════════════════════════════════════════════════ -# 测试：读取噪声模型匹配 -# ── READ_NOISE_EN=1 由 Makefile 保证，测试代码中不再重复门控 -# ═══════════════════════════════════════════════════════════════════════════════ - - @cocotb.test() -async def read_noise_model_match(dut): - """读取噪声模型匹配：验证 RTL 的读取噪声行为与 Python 参考模型一致。 - - 与写入噪声不同，读取噪声发生在查询阶段（每次查询向哈希值注入噪声）， - 因此： - - 如果先有写入噪声，存储行已经被翻转过一次 - - 然后查询时还会再注入一层读取噪声 - - 两层噪声使用不同的种子（写: 0xB504..., 读: 0x6A09...） - - 本测试： - 1. 用 Python 模型预计算存储后的哈希（含写入噪声） - 2. 用 match_top1_with_read_noise 预计算含读取噪声的期望结果 - 3. 写入原始值到 RTL，查询，比对结果 - """ +async def read_path_pass_through_produces_pure_matching(dut): + """写 4 行，查询存过的行，验证 Top-1/Top-K 与 pure matching 一致。""" cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) await reset_dut(dut) num_rows = dut_num_rows(dut) hash_bits = dut_hash_bits(dut) - lanes = dut_lanes(dut) - rng = np.random.default_rng(123) + rng = np.random.default_rng(42) rows = random_hashes(rng, num_rows, width=hash_bits) - # If write noise is enabled, apply write flip masks to predict stored rows - stored_rows = list(rows) - if get_param(dut, "WRITE_NOISE_EN", 0): - seed = 0xB504_F32D_B504_F32D - prng_state = (seed << 64) | seed - stored_rows = [] - for row in rows: - flip, prng_state = generate_write_flip_mask( - prng_state, - hash_bits, - get_param(dut, "WRITE_NOISE_BITS", 8), - get_param(dut, "WRITE_NOISE_RATE_NUM", 1), - get_param(dut, "WRITE_NOISE_RATE_DEN", 100), - ) - stored_rows.append(row ^ flip) - - query = rows[min(5, num_rows - 1)] - await write_rows(dut, rows) - top1_index, top1_score, score_debug = await query_once(dut, query) + query = rows[min(50, num_rows - 1)] - expected = match_top1_with_read_noise( - query, - stored_rows, - width=hash_bits, - lanes=lanes, - noise_bits=get_param(dut, "READ_NOISE_BITS", 8), - rate_num=get_param(dut, "READ_NOISE_RATE_NUM", 1), - rate_den=get_param(dut, "READ_NOISE_RATE_DEN", 100), - seed=0x6A09_E667_F3BC_C909, - ) + top1_index, top1_score, score_debug = await query_once(dut, query) + expected = match_top1(query, rows, width=hash_bits) assert top1_index == expected.top1_index assert top1_score == expected.top1_score diff --git a/hw/sim/tests/top/write_noise/Makefile b/hw/sim/tests/top/write_noise/Makefile index a23b387..34c8871 100644 --- a/hw/sim/tests/top/write_noise/Makefile +++ b/hw/sim/tests/top/write_noise/Makefile @@ -10,7 +10,6 @@ VERILOG_SOURCES := $(RTL_CAM_TOP) WRITE_NOISE_EN := 1 WRITE_NOISE_RATE_NUM := 1 WRITE_NOISE_RATE_DEN := 100 -READ_NOISE_EN := 0 include $(SIM_ROOT)/mk/cocotb-common.mk diff --git a/hw/sim/tests/top/write_noise/test_write_noise.py b/hw/sim/tests/top/write_noise/test_write_noise.py index 4e78b30..141d0cf 100644 --- a/hw/sim/tests/top/write_noise/test_write_noise.py +++ b/hw/sim/tests/top/write_noise/test_write_noise.py @@ -2,7 +2,7 @@ """ CAM 写入噪声（Write Noise）集成测试 —— 专用配置。 -本文件测试 WRITE_NOISE_EN=1, READ_NOISE_EN=0 配置下， +本文件测试 WRITE_NOISE_EN=1 配置下， 写入噪声模块的正确性。默认噪声率约 1%（NUM=1, DEN=100）。 === 测试列表 === @@ -14,7 +14,7 @@ CAM 写入噪声（Write Noise）集成测试 —— 专用配置。 === 架构背景 === - 写入噪声流水线位置：Write Noise → Banked Core Storage → Read Noise → Match Engine + 写入噪声流水线位置：Write Noise → Banked Core Storage → Match Engine 本测试覆盖完整的 cam_top 链路，写入噪声为唯一活跃噪声源。 === Makefile 子目标 === @@ -30,7 +30,6 @@ import numpy as np from cocotb.clock import Clock from cocotb.triggers import RisingEdge from model.ref_model import ( - generate_write_flip_mask, match_top1, random_hashes, ) @@ -89,71 +88,7 @@ async def default_noise_reproducible(dut): # ═══════════════════════════════════════════════════════════════════════════════ -# 测试 2：精确 RTL-vs-模型 PRNG 掩码匹配 -# ── RTL 存储的哈希与 ref_model.py 生成的掩码逐位一致 -# ═══════════════════════════════════════════════════════════════════════════════ - - -@cocotb.test() -async def exact_noise_model_match(dut): - """精确噪声模型匹配：RTL 的 PRNG 输出必须与 Python 参考模型逐位一致。 - - 测试方法： - 1. 用固定 RTL seed 和已知噪声参数，在 Python 中预计算每行的 flip 掩码 - 2. 预期存储值 = 原始值 XOR flip_mask - 3. 写入原始值到 RTL，查询预期存储值 - 4. 断言每行 score = HASH_BITS（完全匹配） - - 这验证了 RTL 的 LFSR 实现与 Python 模型的 PRNG 使用相同的 - 多项式、相同的位宽、相同的种子初始化序列。 - """ - if not hasattr(dut, "score_debug_flat"): - dut._log.info("Skipping exact_noise_model_match: requires SIM_DEBUG.") - return - - rtol = None - atol = None - cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) - await reset_dut(dut) - - hash_bits = dut_hash_bits(dut) - noise_bits = get_param(dut, "WRITE_NOISE_BITS", 8) - rate_num = get_param(dut, "WRITE_NOISE_RATE_NUM", 1) - rate_den = get_param(dut, "WRITE_NOISE_RATE_DEN", 100) - - n_test_rows = 4 - rng = np.random.default_rng(99) - rows = random_hashes(rng, n_test_rows, width=hash_bits) - - RTL_SEED = 0xB504_F32D_B504_F32D - prng_state = (RTL_SEED << 64) | RTL_SEED - expected_stored = [] - for row in rows: - flip, prng_state = generate_write_flip_mask( - prng_state, - hash_bits, - noise_bits, - rate_num, - rate_den, - ) - expected_stored.append(row ^ flip) - - for idx, val in enumerate(rows): - await write_row(dut, idx, val) - - for idx, expected in enumerate(expected_stored): - top1_index, top1_score, score_debug = await query_once(dut, expected) - assert score_debug is not None, ( - "score_debug required for mask match verification" - ) - assert int(score_debug[idx]) == hash_bits, ( - f"Row {idx}: expected stored hash to match model prediction, " - f"score={score_debug[idx]} != {hash_bits}" - ) - - -# ═══════════════════════════════════════════════════════════════════════════════ -# 测试 3：零噪声率（WRITE_NOISE_EN=1, RATE_NUM=0） +# 测试 2：零噪声率（WRITE_NOISE_EN=1, RATE_NUM=0） # ── 噪声模块已连接但翻转概率为 0 → 行为应与无噪声一致 # ═══════════════════════════════════════════════════════════════════════════════ @@ -195,80 +130,4 @@ async def zero_rate_noise(dut): assert np.array_equal(score_debug, expected.scores) -# ═══════════════════════════════════════════════════════════════════════════════ -# 测试 4：100% 噪声率（RATE_NUM=1, RATE_DEN=1） -# ── 每组都翻转 → 精确验证 PRNG 掩码生成 -# ═══════════════════════════════════════════════════════════════════════════════ - -@cocotb.test() -async def full_rate_noise(dut): - """完全速率噪声：每组 100% 翻转概率。 - - 使用固定 RTL seed (0xB504F32DB504F32D)，用 Python 模型预计算 - 写入全 0 和全 1 行后应存储的哈希值，然后验证 RTL 实际存储的哈希 - 与模型预测完全一致。 - - 这是最低容忍度的噪声测试——要求 score_debug_flat（SIM_DEBUG） - 且每行的分数必须精确等于 HASH_BITS。 - """ - rate_num = get_param(dut, "WRITE_NOISE_RATE_NUM", 1) - rate_den = get_param(dut, "WRITE_NOISE_RATE_DEN", 100) - if rate_num != 1 or rate_den != 1: - dut._log.info( - "Skipping full_rate_noise: requires WRITE_NOISE_RATE_NUM=1, RATE_DEN=1." - ) - return - if not hasattr(dut, "score_debug_flat"): - dut._log.info( - "Skipping full_rate_noise: requires SIM_DEBUG (score_debug_flat)." - ) - return - - cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) - await reset_dut(dut) - - hash_bits = dut_hash_bits(dut) - num_rows = dut_num_rows(dut) - noise_bits = get_param(dut, "WRITE_NOISE_BITS", 8) - all_zero = 0 - all_one = (1 << hash_bits) - 1 - - RTL_SEED = 0xB504_F32D_B504_F32D - prng_state = (RTL_SEED << 64) | RTL_SEED - - flip0, prng_state = generate_write_flip_mask( - prng_state, - hash_bits, - noise_bits, - rate_num, - rate_den, - ) - expected_row0 = all_zero ^ flip0 - - flip1, prng_state = generate_write_flip_mask( - prng_state, - hash_bits, - noise_bits, - rate_num, - rate_den, - ) - expected_row1 = all_one ^ flip1 - - rows = [0] * num_rows - rows[0] = all_zero - rows[1] = all_one - - await write_rows(dut, rows) - - top1_index, top1_score, score_debug = await query_once(dut, expected_row0) - assert score_debug is not None, "score_debug required for full_rate_noise" - assert int(score_debug[0]) == hash_bits, ( - f"Row 0: expected exact match, score={score_debug[0]} != {hash_bits}" - ) - - top1_index, top1_score, score_debug = await query_once(dut, expected_row1) - assert score_debug is not None - assert int(score_debug[1]) == hash_bits, ( - f"Row 1: expected exact match, score={score_debug[1]} != {hash_bits}" - ) diff --git a/hw/syn/synth_cam_top_flat.ys b/hw/syn/synth_cam_top_flat.ys index ca76468..1e59893 100644 --- a/hw/syn/synth_cam_top_flat.ys +++ b/hw/syn/synth_cam_top_flat.ys @@ -10,7 +10,7 @@ verilog_defaults -add -I../rtl/random # Read RTL sources in canonical order read_verilog -sv -D SYNTHESIS ../rtl/random/random128.sv -read_verilog -sv -D SYNTHESIS ../rtl/noise/noise_mask_grouped.sv +read_verilog -sv -D SYNTHESIS ../rtl/noise/noise_mask_bernoulli.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_write_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv diff --git a/hw/syn/synth_cam_top_hier.ys b/hw/syn/synth_cam_top_hier.ys index 5dba7ca..45e3102 100644 --- a/hw/syn/synth_cam_top_hier.ys +++ b/hw/syn/synth_cam_top_hier.ys @@ -10,7 +10,7 @@ verilog_defaults -add -I../rtl/random # Read RTL sources in canonical order read_verilog -sv -D SYNTHESIS ../rtl/random/random128.sv -read_verilog -sv -D SYNTHESIS ../rtl/noise/noise_mask_grouped.sv +read_verilog -sv -D SYNTHESIS ../rtl/noise/noise_mask_bernoulli.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_write_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv