SikongJueluo/Mini-Nav
1
0
Fork 0
mirror of https://github.com/SikongJueluo/Mini-Nav.git synced 2026-07-12 20:15:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(cam): remove read noise from noise architecture (Phase 2)

Browse Source 
- Make cam_read_noise a pass-through module, removing all noise injection logic
- Switch write noise to use noise_mask_bernoulli instead of noise_mask_grouped
- Add state machine to cam_write_noise for mask generation timing
- Remove noise_mask_grouped.sv (no longer needed)
- Remove read noise parameters from cam_noisy and cam_top
- Update simulation and benchmark code to reflect read noise removal
- Sync documentation to reflect Phase 2 architecture
This commit is contained in:
SikongJueluo
2026-05-26 23:02:22 +08:00
parent e5d13917b2
commit 8b4d4c1b57
29 changed files with 277 additions and 863 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
.justfile
View File

@@ -76,11 +76,11 @@ cam-test MODULE TESTCASE:
# Run CAM retrieval benchmark without hardware noise # Run CAM retrieval benchmark without hardware noise
cam-test-retrieval-no-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: 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 # Prepare CIFAR10 hash artifact for CAM retrieval smoke benchmark
cam-prepare-retrieval-cifar10 ROWS="512" QUERIES="128": 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 # Run CAM retrieval benchmark on a prepared artifact without hardware noise
cam-test-retrieval-artifact DATASET_PATH NUM_ROWS="4096": 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": 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 }}"

1
.stignore
View File

@@ -7,6 +7,7 @@
.ruff_cache .ruff_cache
.opencode .opencode
.backup .backup
.codegraph
data data
datasets datasets
deps deps

4
docs/experiments.md
View File

@@ -31,7 +31,7 @@
- `hw/rtl/core/popcount_pipeline.sv` - `hw/rtl/core/popcount_pipeline.sv`
- `hw/rtl/noise/cam_write_noise.sv` - `hw/rtl/noise/cam_write_noise.sv`
- `hw/rtl/noise/cam_read_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/rtl/cam_params.svh`
- `hw/sim/model/ref_model.py` - `hw/sim/model/ref_model.py`
- `hw/sim/sweep_noise.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` - 写入/读取：`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` - 匹配与 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/model/ref_model.py`
- 集成测试：`hw/sim/tests/test_cam_basic.py` - 集成测试：`hw/sim/tests/test_cam_basic.py`

17
hw/rtl/cam_noisy.sv
View File

@@ -5,13 +5,7 @@ module cam_noisy #(
parameter bit WRITE_NOISE_EN = 1'b1, parameter bit WRITE_NOISE_EN = 1'b1,
parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_NUM = 1,
parameter int WRITE_NOISE_RATE_DEN = 100, 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 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
) ( ) (
input logic clk, input logic clk,
input logic rst_n, input logic rst_n,
@@ -42,7 +36,6 @@ module cam_noisy #(
.WRITE_NOISE_EN (WRITE_NOISE_EN), .WRITE_NOISE_EN (WRITE_NOISE_EN),
.WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), .WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM),
.WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN), .WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN),
.WRITE_NOISE_BITS (WRITE_NOISE_BITS),
.WRITE_NOISE_SEED (WRITE_NOISE_SEED) .WRITE_NOISE_SEED (WRITE_NOISE_SEED)
) u_write_noise ( ) u_write_noise (
.clk (clk), .clk (clk),
@@ -73,13 +66,7 @@ module cam_noisy #(
); );
// ── Read noise pipeline ── // ── Read noise pipeline ──
cam_read_noise #( cam_read_noise u_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 (
.clk (clk), .clk (clk),
.rst_n (rst_n), .rst_n (rst_n),
.valid_i (core_rd_valid), .valid_i (core_rd_valid),

16
hw/rtl/cam_top.sv
View File

@@ -5,13 +5,7 @@ module cam_top #(
parameter bit WRITE_NOISE_EN = 1'b1, parameter bit WRITE_NOISE_EN = 1'b1,
parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_NUM = 1,
parameter int WRITE_NOISE_RATE_DEN = 100, 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 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
) ( ) (
input logic clk, input logic clk,
input logic rst_n, input logic rst_n,
@@ -77,13 +71,7 @@ module cam_top #(
.WRITE_NOISE_EN (WRITE_NOISE_EN), .WRITE_NOISE_EN (WRITE_NOISE_EN),
.WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), .WRITE_NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM),
.WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN), .WRITE_NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN),
.WRITE_NOISE_BITS (WRITE_NOISE_BITS), .WRITE_NOISE_SEED (WRITE_NOISE_SEED)
.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)
) u_noisy ( ) u_noisy (
.clk (clk), .clk (clk),
.rst_n (rst_n), .rst_n (rst_n),

68
hw/rtl/noise/cam_read_noise.sv
View File

@@ -1,13 +1,7 @@
`timescale 1ns / 1ps `timescale 1ns / 1ps
`include "cam_params.svh" `include "cam_params.svh"
module cam_read_noise #( 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
) (
input logic clk, input logic clk,
input logic rst_n, input logic rst_n,
input logic valid_i, 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)*(`HASH_BITS)-1:0] hashes_noisy_o,
output logic [(`LANES)-1:0] lane_valid_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 always_ff @(posedge clk or negedge rst_n) begin
if (!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; valid_o <= 1'b0;
row_ids_o <= '0; row_ids_o <= '0;
hashes_noisy_o <= '0; hashes_noisy_o <= '0;
lane_valid_o <= '0; lane_valid_o <= '0;
end else begin end else begin
valid_q <= valid_i; valid_o <= valid_i;
row_ids_q <= row_ids_i; row_ids_o <= row_ids_i;
hashes_q <= hashes_i; hashes_noisy_o <= hashes_i;
lane_valid_q <= lane_valid_i; lane_valid_o <= 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
end end
end end
endmodule endmodule

112
hw/rtl/noise/cam_write_noise.sv
View File

@@ -5,7 +5,6 @@ module cam_write_noise #(
parameter bit WRITE_NOISE_EN = 1'b1, parameter bit WRITE_NOISE_EN = 1'b1,
parameter int WRITE_NOISE_RATE_NUM = 1, parameter int WRITE_NOISE_RATE_NUM = 1,
parameter int WRITE_NOISE_RATE_DEN = 100, 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 logic [63:0] WRITE_NOISE_SEED = 64'hB504_F32D_B504_F32D
) ( ) (
input logic clk, input logic clk,
@@ -18,30 +17,46 @@ module cam_write_noise #(
output logic [(`ROW_BITS)-1:0] core_wr_row, output logic [(`ROW_BITS)-1:0] core_wr_row,
output logic [(`HASH_BITS)-1:0] core_wr_hash output logic [(`HASH_BITS)-1:0] core_wr_hash
); );
logic pending_q;
logic [(`ROW_BITS)-1:0] row_q; localparam int PROB_BITS = 8;
logic [(`HASH_BITS)-1:0] hash_q; localparam int SAMPLE_RANGE = 1 << PROB_BITS;
logic [127:0] random_num; 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 [(`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 ( noise_mask_bernoulli #(
.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 #(
.HASH_BITS (`HASH_BITS), .HASH_BITS (`HASH_BITS),
.NOISE_BITS (WRITE_NOISE_BITS), .PROB_BITS (PROB_BITS),
.NOISE_RATE_NUM (WRITE_NOISE_RATE_NUM), .PRNG_WORDS (2),
.NOISE_RATE_DEN (WRITE_NOISE_RATE_DEN) .BITS_PER_CYCLE (32),
) u_mask ( .SEED (WRITE_NOISE_SEED)
.random_i(random_num), ) u_bernoulli_mask (
.mask_o (flip_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 `ifndef SYNTHESIS
@@ -52,26 +67,47 @@ module cam_write_noise #(
always_ff @(posedge clk or negedge rst_n) begin always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin if (!rst_n) begin
pending_q <= 1'b0; state_q <= STATE_IDLE;
row_q <= '0; mask_start_q <= 1'b0;
hash_q <= '0; row_q <= '0;
hash_q <= '0;
core_wr_valid <= 1'b0; core_wr_valid <= 1'b0;
core_wr_row <= '0; core_wr_row <= '0;
core_wr_hash <= '0; core_wr_hash <= '0;
end else begin end else begin
core_wr_valid <= pending_q; core_wr_valid <= 1'b0;
core_wr_row <= row_q; mask_start_q <= 1'b0;
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
pending_q <= wr_valid && wr_ready; unique case (state_q)
if (wr_valid && wr_ready) begin STATE_IDLE: begin
row_q <= wr_row; if (wr_valid && wr_ready) begin
hash_q <= wr_hash; row_q <= wr_row;
end 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
end end
endmodule endmodule

39
hw/rtl/noise/noise_mask_grouped.sv
View File

@@ -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

1
hw/sim/benchmarks/retrieval/Makefile
View File

@@ -9,7 +9,6 @@ VERILOG_SOURCES := $(RTL_CAM_TOP)
TOPK_K ?= 5 TOPK_K ?= 5
NUM_ROWS ?= 4096 NUM_ROWS ?= 4096
WRITE_NOISE_EN ?= 0 WRITE_NOISE_EN ?= 0
READ_NOISE_EN ?= 0
CAM_RETRIEVAL_DATASET ?= CAM_RETRIEVAL_DATASET ?=
export CAM_RETRIEVAL_DATASET export CAM_RETRIEVAL_DATASET

35
hw/sim/benchmarks/retrieval/test_retrieval_benchmark.py
View File

@@ -12,10 +12,8 @@ import numpy as np
from cocotb.clock import Clock from cocotb.clock import Clock
from model.ref_model import ( from model.ref_model import (
lane_seed_128,
match_topk, match_topk,
match_topk_from_scores, match_topk_from_scores,
score_rows_with_read_noise,
) )
from tests.top.utils import ( from tests.top.utils import (
dut_hash_bits, dut_hash_bits,
@@ -199,13 +197,9 @@ def compute_metrics(topk_indices: list[int], row_labels: list[int], query_label:
return precision, recall, f1 return precision, recall, f1
def mode_from_params(write_noise_en: int, read_noise_en: int) -> str: def mode_from_params(write_noise_en: int) -> str:
if write_noise_en and read_noise_en:
return "write_read_noise"
if write_noise_en: if write_noise_en:
return "write_noise" return "write_noise"
if read_noise_en:
return "read_noise"
return "no_noise" return "no_noise"
@@ -228,8 +222,8 @@ def write_outputs(out_dir: Path, result: dict) -> None:
fieldnames = [ fieldnames = [
"run_id", "mode", "num_rows", "hash_bits", "lanes", "topk_k", "run_id", "mode", "num_rows", "hash_bits", "lanes", "topk_k",
"write_noise_en", "read_noise_en", "write_noise_rate_num", "write_noise_en", "write_noise_rate_num",
"write_noise_rate_den", "read_noise_rate_num", "read_noise_rate_den", "write_noise_rate_den",
"num_queries", "k", "macro_precision", "retrieval_recall", "macro_f1", "num_queries", "k", "macro_precision", "retrieval_recall", "macro_f1",
"recall@k", "exact_match_rate", "status", "recall@k", "exact_match_rate", "status",
] ]
@@ -245,11 +239,8 @@ def write_outputs(out_dir: Path, result: dict) -> None:
"lanes": result["params"]["lanes"], "lanes": result["params"]["lanes"],
"topk_k": result["params"]["topk_k"], "topk_k": result["params"]["topk_k"],
"write_noise_en": result["params"]["write_noise_en"], "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_num": result["params"]["write_noise_rate_num"],
"write_noise_rate_den": result["params"]["write_noise_rate_den"], "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"], "num_queries": result["dataset"]["num_queries"],
"k": int(k), "k": int(k),
"macro_precision": metrics["macro_precision"], "macro_precision": metrics["macro_precision"],
@@ -293,13 +284,9 @@ async def cam_retrieval_benchmark(dut):
hash_bits = dut_hash_bits(dut) hash_bits = dut_hash_bits(dut)
lanes = dut_lanes(dut) lanes = dut_lanes(dut)
write_noise_en = int(get_param(dut, "WRITE_NOISE_EN", 0) or 0) 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_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) 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) mode = mode_from_params(write_noise_en)
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)
if write_noise_en: if write_noise_en:
raise AssertionError("First retrieval benchmark version only supports WRITE_NOISE_EN=0") 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) await write_rows(dut, dataset.rows)
accumulators = {k: MetricAccumulator() for k in BENCHMARK_KS} 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): for query, query_label in zip(dataset.queries, dataset.query_labels):
beats, _, _, _ = await query_topk_once(dut, query) 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)]] dut_topk = [int(beat[1]) for beat in beats[: max(BENCHMARK_KS)]]
if read_noise_en: golden_topk, _ = match_topk(query, dataset.rows, width=hash_bits, k=max(BENCHMARK_KS))
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))
for k in BENCHMARK_KS: for k in BENCHMARK_KS:
precision, recall, f1 = compute_metrics(dut_topk, dataset.row_labels, query_label, k) 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, "lanes": lanes,
"topk_k": max(BENCHMARK_KS), "topk_k": max(BENCHMARK_KS),
"write_noise_en": write_noise_en, "write_noise_en": write_noise_en,
"read_noise_en": read_noise_en,
"write_noise_rate_num": write_noise_rate_num, "write_noise_rate_num": write_noise_rate_num,
"write_noise_rate_den": write_noise_rate_den, "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": { "dataset": {
"num_classes": dataset.num_classes, "num_classes": dataset.num_classes,

20
hw/sim/mk/cocotb-common.mk
View File

@@ -37,11 +37,6 @@ COMPILE_ARGS += $(EXTRA_DEFINES)
WRITE_NOISE_EN ?= $(NOISE_EN) WRITE_NOISE_EN ?= $(NOISE_EN)
WRITE_NOISE_RATE_NUM ?= $(NOISE_RATE_NUM) WRITE_NOISE_RATE_NUM ?= $(NOISE_RATE_NUM)
WRITE_NOISE_RATE_DEN ?= $(NOISE_RATE_DEN) 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)),) ifneq ($(strip $(WRITE_NOISE_EN)),)
COMPILE_ARGS += -GWRITE_NOISE_EN=$(WRITE_NOISE_EN) COMPILE_ARGS += -GWRITE_NOISE_EN=$(WRITE_NOISE_EN)
@@ -52,21 +47,6 @@ endif
ifneq ($(strip $(WRITE_NOISE_RATE_DEN)),) ifneq ($(strip $(WRITE_NOISE_RATE_DEN)),)
COMPILE_ARGS += -GWRITE_NOISE_RATE_DEN=$(WRITE_NOISE_RATE_DEN) COMPILE_ARGS += -GWRITE_NOISE_RATE_DEN=$(WRITE_NOISE_RATE_DEN)
endif 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 PYTHONPATH := $(SIM_ROOT):$(PYTHONPATH)
export QUIET ?= 1 export QUIET ?= 1

5
hw/sim/mk/rtl-sources.mk
View File

@@ -4,10 +4,9 @@ endif
RTL_RANDOM := $(RTL_ROOT)/random/random128.sv 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_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_WRITE_NOISE := $(RTL_BERNOULLI_NOISE_MASK) $(RTL_ROOT)/noise/cam_write_noise.sv
RTL_READ_NOISE := $(RTL_NOISE_MASK) $(RTL_RANDOM) $(RTL_ROOT)/noise/cam_read_noise.sv RTL_READ_NOISE := $(RTL_ROOT)/noise/cam_read_noise.sv
RTL_CAM_CORE_BANKED := $(RTL_ROOT)/core/cam_core_banked.sv RTL_CAM_CORE_BANKED := $(RTL_ROOT)/core/cam_core_banked.sv
RTL_MATCH_ENGINE := \ RTL_MATCH_ENGINE := \

198
hw/sim/model/ref_model.py
View File

@@ -94,204 +94,6 @@ def xorshift128(state: int) -> int:
return ((next_x << 96) | (next_y << 64) | (next_z << 32) | next_w) & mask128 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( def random_hashes(
rng: np.random.Generator, rng: np.random.Generator,
n: int, n: int,

17
hw/sim/scripts/sweep_noise.py
View File

@@ -16,7 +16,6 @@ if str(SIM_ROOT) not in sys.path:
import numpy as np import numpy as np
from model.ref_model import ( from model.ref_model import (
generate_write_flip_mask,
match_top1, match_top1,
random_hashes, random_hashes,
) )
@@ -31,20 +30,12 @@ def apply_write_noise(
noise_bits: int = 8, noise_bits: int = 8,
seed: int = 0, seed: int = 0,
) -> list[int]: ) -> 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 sweep now measures top-1 stability of pure matching over queries,
the 128-bit xorshift initial state: {seed, seed}. since noise is applied at RTL write time, not in the Python model.
""" """
noisy: list[int] = [] return list(rows)
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
def main() -> None: def main() -> None:

197
hw/sim/tests/model/test_ref_model_noise.py
View File

@@ -1,94 +1,31 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
""" """
参考模型（ref_model）的纯 Python 单元测试。 参考模型（ref_model）的纯 Python 单元测试 — Phase 2 cleaned.
本文件不涉及任何 RTL / Verilator 仿真，仅验证 Python 参考模型的正确性。 本文件不涉及任何 RTL / Verilator 仿真，仅验证 Python 参考模型的正确性。
所有 RTL-vs-模型 的对比测试（如顶层 test_cam_basic.py）都依赖此参考模型， Phase 2 后只保留 pure matching 函数；所有 grouped/read-noise helpers 已删除。
因此这里是整个测试体系的「基石」——参考模型如果有 bug，所有对比测试都将失效。
测试覆盖： 测试覆盖：
1. 分组翻转掩码 — 完全速率 (rate=1/1) 的正确位翻转模式 1. XNOR 评分语义 — 确认是「匹配位数」而非「汉明距离」
2. 分组翻转掩码 — 零速率 (rate=0/100) 不应产生任何翻转 2. Top-1 matching — 纯匹配，正确选出最高分索引
3. 评分函数语义 — 确认是「匹配位数」而非「汉明距离」 3. Top-K matching — 返回排序后的行索引列表
4. 读取噪声模型 — 相同输入 + 相同种子 = 可复现结果 4. Top-K 排序规则 — 分数降序、平局行号升序
5. Top-K k 超过行数时 clamp
""" """
from __future__ import annotations from __future__ import annotations
from model.ref_model import ( from model.ref_model import (
generate_grouped_flip_mask, match_top1,
match_top1_with_read_noise, match_topk,
match_topk_from_scores,
xnor_popcount_score, xnor_popcount_score,
) )
import numpy as np
# ============================================================================== # ==============================================================================
# 测试 1：完全速率下的分组翻转掩码生成 # 测试 1：评分函数语义 — 确认是「XNOR 匹配位数」而非「汉明距离」
# ==============================================================================
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 匹配位数」而非「汉明距离」
# ============================================================================== # ==============================================================================
@@ -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(): def test_match_top1_selects_highest_xnor_score_with_row_index_tiebreak():
""" """Top-1 应选出 XNOR 分最高的行；平局时选最小行号。"""
验证 match_top1_with_read_noise 在相同参数下产生相同结果。 rows = [0b0000, 0b1111, 0b0011, 0b0101]
query = 0b0000
为什么这个测试至关重要： result = match_top1(query, rows, width=4)
- RTL 中的 read noise PRNG 使用固定种子 (0x6A09E667F3BCC909) assert result.top1_index == 0
- 参考模型必须使用相同的种子来复现 RTL 的噪声行为 assert result.top1_score == 4
- 如果两次调用结果不同，说明模型存在非确定性 bug assert result.scores.tolist() == [4, 0, 2, 2]
（如未重置 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()
# ============================================================================== # ==============================================================================
# 测试 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(): def test_match_topk_scores_rows_by_xnor_popcount():
"""match_topk 通过 xnor_popcount 计算分数，返回排序后的行索引和分数数组。""" """match_topk 通过 xnor_popcount 计算分数，返回排序后的行索引和分数数组。"""
from model.ref_model import match_topk
rows = [0b0000, 0b1111, 0b0011, 0b0101] rows = [0b0000, 0b1111, 0b0011, 0b0101]
query = 0b0000 query = 0b0000
indices, scores = match_topk(query, rows, width=4, k=3) 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] 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(): def test_match_topk_clamps_k_to_row_count():
"""当 k 超过实际行数时，返回所有行（按排序）。""" """当 k 超过实际行数时，返回所有行（按排序）。"""
from model.ref_model import match_topk
indices, scores = match_topk(0, [0, 1], width=1, k=5) indices, scores = match_topk(0, [0, 1], width=1, k=5)
assert scores.tolist() == [1, 0] assert scores.tolist() == [1, 0]
assert indices == [0, 1] 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

4
hw/sim/tests/modules/cam_read_noise/Makefile
View File

@@ -7,9 +7,5 @@ COCOTB_TEST_MODULES := tests.modules.cam_read_noise.test_cam_read_noise
VERILOG_SOURCES := $(RTL_READ_NOISE) VERILOG_SOURCES := $(RTL_READ_NOISE)
HASH_BITS ?= 512 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 include $(SIM_ROOT)/mk/cocotb-common.mk

42
hw/sim/tests/modules/cam_read_noise/test_cam_read_noise.py
View File

@@ -2,7 +2,7 @@ from __future__ import annotations
import cocotb import cocotb
from cocotb.clock import Clock from cocotb.clock import Clock
from cocotb.triggers import RisingEdge from cocotb.triggers import RisingEdge, Timer
async def reset_read_noise(dut): 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.row_ids_i.value = rows
dut.lane_valid_i.value = all_lanes_valid dut.lane_valid_i.value = all_lanes_valid
dut.valid_i.value = 1 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 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.valid_o.value) == 1
assert int(dut.hashes_noisy_o.value) == hashes assert int(dut.hashes_noisy_o.value) == hashes
assert int(dut.row_ids_o.value) == rows assert int(dut.row_ids_o.value) == rows

2
hw/sim/tests/modules/cam_write_noise/Makefile
View File

@@ -10,6 +10,4 @@ HASH_BITS ?= 512
WRITE_NOISE_EN ?= 1 WRITE_NOISE_EN ?= 1
WRITE_NOISE_RATE_NUM ?= 1 WRITE_NOISE_RATE_NUM ?= 1
WRITE_NOISE_RATE_DEN ?= 100 WRITE_NOISE_RATE_DEN ?= 100
WRITE_NOISE_BITS ?= $(shell echo $$(( $(HASH_BITS) / 64 )))
include $(SIM_ROOT)/mk/cocotb-common.mk include $(SIM_ROOT)/mk/cocotb-common.mk

85
hw/sim/tests/modules/cam_write_noise/test_cam_write_noise.py
View File

@@ -2,8 +2,32 @@ from __future__ import annotations
import cocotb import cocotb
from cocotb.clock import Clock from cocotb.clock import Clock
from cocotb.triggers import RisingEdge from cocotb.triggers import RisingEdge, Timer
from model.ref_model import generate_write_flip_mask
# 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): async def reset_write_noise(dut):
@@ -19,23 +43,52 @@ async def reset_write_noise(dut):
@cocotb.test() @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()) cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start())
await reset_write_noise(dut) await reset_write_noise(dut)
value = 0x123456789ABCDEF value = (1 << 512) - 1 # all-ones: even low-rate Bernoulli may flip some bits
dut.wr_row.value = 3 await pulse_write(dut, row=3, value=value)
dut.wr_hash.value = value await Timer(1, unit="step")
dut.wr_valid.value = 1 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 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 dut.wr_valid.value = 0
while int(dut.core_wr_valid.value) == 0: cycles = await wait_core_write(dut)
await RisingEdge(dut.clk) assert cycles == DEFAULT_WRITE_NOISE_LATENCY - 4 # 19 - 4 = 15
assert int(dut.core_wr_row.value) == 1
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)

3
hw/sim/tests/perf/Makefile
View File

@@ -8,8 +8,5 @@ VERILOG_SOURCES := $(RTL_CAM_TOP)
HASH_BITS ?= 512 HASH_BITS ?= 512
WRITE_NOISE_EN := 0 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 include $(SIM_ROOT)/mk/cocotb-common.mk

9
hw/sim/tests/perf/test_cam_perf.py
View File

@@ -243,7 +243,6 @@ async def cam_perf_benchmark(dut):
hash_bits = dut_hash_bits(dut) hash_bits = dut_hash_bits(dut)
lanes = dut_lanes(dut) lanes = dut_lanes(dut)
write_noise_en = _get_param(dut, "WRITE_NOISE_EN", 1) write_noise_en = _get_param(dut, "WRITE_NOISE_EN", 1)
read_noise_en = _get_param(dut, "READ_NOISE_EN", 0)
# ── Deterministic query ───────────────────────────────────────────── # ── Deterministic query ─────────────────────────────────────────────
query_hash = 0xAA55_AA55_AA55_AA55_AA55_AA55_AA55_AA55 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) ───────────── # ── 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. # Without noise: stored hash at row 0 == query_hash → exact match.
assert top1_index == 0, ( assert top1_index == 0, (
f"Noise disabled: expected top1_index=0 (exact match), got " f"Noise disabled: expected top1_index=0 (exact match), got "
@@ -282,7 +281,7 @@ async def cam_perf_benchmark(dut):
f"{top1_score}" f"{top1_score}"
) )
else: 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 # we cannot reliably assert the exact match. Instead, confirm a
# valid non-zero score was produced (the match engine ran). # valid non-zero score was produced (the match engine ran).
assert top1_score > 0, ( assert top1_score > 0, (
@@ -290,10 +289,10 @@ async def cam_perf_benchmark(dut):
"Match engine returned invalid result." "Match engine returned invalid result."
) )
dut._log.info( 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. " "skipping exact top1_index/top1_score assertion. "
"top1_index=%d top1_score=%d", "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 ───────────────────────────── # ── Machine-readable performance marker ─────────────────────────────

1
hw/sim/tests/top/no_noise/Makefile
View File

@@ -8,6 +8,5 @@ VERILOG_SOURCES := $(RTL_CAM_TOP)
# 禁用所有噪声模块 # 禁用所有噪声模块
WRITE_NOISE_EN := 0 WRITE_NOISE_EN := 0
READ_NOISE_EN := 0
include $(SIM_ROOT)/mk/cocotb-common.mk include $(SIM_ROOT)/mk/cocotb-common.mk

8
hw/sim/tests/top/no_noise/test_no_noise.py
View File

@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*- # -*- 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 在无噪声下的标准行为。 所有噪声模块禁用，验证 CAM 在无噪声下的标准行为。
@@ -17,8 +17,8 @@ CAM 顶层（cam_top）no_noise 配置集成测试（WRITE_NOISE_EN=0, READ_NOIS
=== 配置背景 === === 配置背景 ===
本目录固定使用 WRITE_NOISE_EN=0 和 READ_NOISE_EN=0 编译， 本目录固定使用 WRITE_NOISE_EN=0 编译，
因此所有测试无需运行时参数门控——Makefile 保证配置正确。 因此所有测试无需运行时参数门控——Makefile 保证配置正确。
""" """
from __future__ import annotations 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 行为完全一致 # ── 验证写+查在噪声关闭时与旧 CAM 行为完全一致
# ═══════════════════════════════════════════════════════════════════════════════ # ═══════════════════════════════════════════════════════════════════════════════

5
hw/sim/tests/top/read_noise/Makefile
View File

@@ -6,10 +6,7 @@ TOPLEVEL := cam_top
COCOTB_TEST_MODULES := tests.top.read_noise.test_read_noise COCOTB_TEST_MODULES := tests.top.read_noise.test_read_noise
VERILOG_SOURCES := $(RTL_CAM_TOP) VERILOG_SOURCES := $(RTL_CAM_TOP)
# 读取噪声开启，写入噪声默认关闭 # 读取噪声开启（Phase 2 后为 pass-through），写入噪声默认关闭
READ_NOISE_EN := 1
READ_NOISE_RATE_NUM := 1
READ_NOISE_RATE_DEN := 100
WRITE_NOISE_EN := 0 WRITE_NOISE_EN := 0
include $(SIM_ROOT)/mk/cocotb-common.mk include $(SIM_ROOT)/mk/cocotb-common.mk

87
hw/sim/tests/top/read_noise/test_read_noise.py
View File

@@ -1,27 +1,9 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
""" """
CAM 读取噪声（read_noise）集成测试。 CAM 读取路径 pass-through 集成测试 — Phase 2 cleaned.
本文件针对 READ_NOISE_EN=1 的编译配置，验证 RTL 的读取噪声行为 Read noise 已退休；cam_read_noise 是纯 pass-through。
与 Python 参考模型（ref_model）一致。 本测试验证查询返回的 scores 与 pure matching 一致。
=== 测试内容 ===
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 子目标
启用，测试代码内部已兼容两种配置。
""" """
from __future__ import annotations from __future__ import annotations
@@ -31,83 +13,40 @@ import numpy as np
from cocotb.clock import Clock from cocotb.clock import Clock
from cocotb.triggers import RisingEdge from cocotb.triggers import RisingEdge
from model.ref_model import ( from model.ref_model import (
generate_write_flip_mask, match_top1,
match_top1_with_read_noise,
random_hashes, random_hashes,
unpack_score_debug_flat, unpack_score_debug_flat,
) )
from tests.top.utils import ( from tests.top.utils import (
collect_topk,
dut_hash_bits, dut_hash_bits,
dut_lanes, dut_lanes,
dut_num_rows, dut_num_rows,
get_param, get_param,
query_once, query_once,
query_topk_once,
reset_dut, reset_dut,
write_row,
write_rows, write_rows,
) )
# ═══════════════════════════════════════════════════════════════════════════════
# 测试：读取噪声模型匹配
# ── READ_NOISE_EN=1 由 Makefile 保证，测试代码中不再重复门控
# ═══════════════════════════════════════════════════════════════════════════════
@cocotb.test() @cocotb.test()
async def read_noise_model_match(dut): async def read_path_pass_through_produces_pure_matching(dut):
"""读取噪声模型匹配：验证 RTL 的读取噪声行为与 Python 参考模型一致。 """写 4 行，查询存过的行，验证 Top-1/Top-K 与 pure matching 一致。"""
与写入噪声不同，读取噪声发生在查询阶段（每次查询向哈希值注入噪声），
因此：
- 如果先有写入噪声，存储行已经被翻转过一次
- 然后查询时还会再注入一层读取噪声
- 两层噪声使用不同的种子（写: 0xB504..., 读: 0x6A09...）
本测试：
1. 用 Python 模型预计算存储后的哈希（含写入噪声）
2. 用 match_top1_with_read_noise 预计算含读取噪声的期望结果
3. 写入原始值到 RTL，查询，比对结果
"""
cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start()) cocotb.start_soon(Clock(dut.clk, 10, unit="ns").start())
await reset_dut(dut) await reset_dut(dut)
num_rows = dut_num_rows(dut) num_rows = dut_num_rows(dut)
hash_bits = dut_hash_bits(dut) hash_bits = dut_hash_bits(dut)
lanes = dut_lanes(dut) rng = np.random.default_rng(42)
rng = np.random.default_rng(123)
rows = random_hashes(rng, num_rows, width=hash_bits) 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) 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( top1_index, top1_score, score_debug = await query_once(dut, query)
query, expected = match_top1(query, rows, width=hash_bits)
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,
)
assert top1_index == expected.top1_index assert top1_index == expected.top1_index
assert top1_score == expected.top1_score assert top1_score == expected.top1_score

1
hw/sim/tests/top/write_noise/Makefile
View File

@@ -10,7 +10,6 @@ VERILOG_SOURCES := $(RTL_CAM_TOP)
WRITE_NOISE_EN := 1 WRITE_NOISE_EN := 1
WRITE_NOISE_RATE_NUM := 1 WRITE_NOISE_RATE_NUM := 1
WRITE_NOISE_RATE_DEN := 100 WRITE_NOISE_RATE_DEN := 100
READ_NOISE_EN := 0
include $(SIM_ROOT)/mk/cocotb-common.mk include $(SIM_ROOT)/mk/cocotb-common.mk

147
hw/sim/tests/top/write_noise/test_write_noise.py
View File

@@ -2,7 +2,7 @@
""" """
CAM 写入噪声（Write Noise）集成测试 —— 专用配置。 CAM 写入噪声（Write Noise）集成测试 —— 专用配置。
本文件测试 WRITE_NOISE_EN=1, READ_NOISE_EN=0 配置下， 本文件测试 WRITE_NOISE_EN=1 配置下，
写入噪声模块的正确性。默认噪声率约 1%（NUM=1, DEN=100）。 写入噪声模块的正确性。默认噪声率约 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 链路，写入噪声为唯一活跃噪声源。 本测试覆盖完整的 cam_top 链路，写入噪声为唯一活跃噪声源。
=== Makefile 子目标 === === Makefile 子目标 ===
@@ -30,7 +30,6 @@ import numpy as np
from cocotb.clock import Clock from cocotb.clock import Clock
from cocotb.triggers import RisingEdge from cocotb.triggers import RisingEdge
from model.ref_model import ( from model.ref_model import (
generate_write_flip_mask,
match_top1, match_top1,
random_hashes, random_hashes,
) )
@@ -89,71 +88,7 @@ async def default_noise_reproducible(dut):
# ═══════════════════════════════════════════════════════════════════════════════ # ═══════════════════════════════════════════════════════════════════════════════
# 测试 2：精确 RTL-vs-模型 PRNG 掩码匹配 # 测试 2：零噪声率（WRITE_NOISE_EN=1, RATE_NUM=0）
# ── 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）
# ── 噪声模块已连接但翻转概率为 0 → 行为应与无噪声一致 # ── 噪声模块已连接但翻转概率为 0 → 行为应与无噪声一致
# ═══════════════════════════════════════════════════════════════════════════════ # ═══════════════════════════════════════════════════════════════════════════════
@@ -195,80 +130,4 @@ async def zero_rate_noise(dut):
assert np.array_equal(score_debug, expected.scores) 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}"
)

2
hw/syn/synth_cam_top_flat.ys
View File

@@ -10,7 +10,7 @@ verilog_defaults -add -I../rtl/random
# Read RTL sources in canonical order # Read RTL sources in canonical order
read_verilog -sv -D SYNTHESIS ../rtl/random/random128.sv 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_write_noise.sv
read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv
read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv

2
hw/syn/synth_cam_top_hier.ys
View File

@@ -10,7 +10,7 @@ verilog_defaults -add -I../rtl/random
# Read RTL sources in canonical order # Read RTL sources in canonical order
read_verilog -sv -D SYNTHESIS ../rtl/random/random128.sv 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_write_noise.sv
read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv read_verilog -sv -D SYNTHESIS ../rtl/noise/cam_read_noise.sv
read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv read_verilog -sv -D SYNTHESIS ../rtl/core/cam_core_banked.sv