diff --git a/WORKLOG.md b/WORKLOG.md index 8b24cf3..a730d8b 100644 --- a/WORKLOG.md +++ b/WORKLOG.md @@ -1270,3 +1270,26 @@ integrazione nel top level (F5), verifica consolidata e misure reali (F6). `docs/validation/bugs.md` aggiornato con BUG-003 e BUG-004. - **Prossimo passo**: C.3 (sottosistema memoria — `int8_memory_access`, `memory_interface`, `psram_controller`). + +## Campagna di ri-certificazione — C.3: Sottosistema memoria (2026-09-04) + +- **`int8_memory_access.v` certificato esaustivamente** (nuovo test, non esisteva prima): + 2048 indirizzi (ogni combinazione dei 12 bit bassi, entrambe le parità) per la conversione + byte→word e selezione byte-lane, più 6 round-trip scrittura/lettura reali attraverso + l'handshake FSM (incl. verifica che scrivere il byte dispari di una parola non corrompa il + byte pari fratello). **2054/2054 controlli, 0 mismatch** — dopo aver corretto due difetti + nella mia stessa testbench (controllo dei segnali nello stesso passo dell'aggiornamento + non-bloccante; uno stub di memoria che ignorava le byte-lane in scrittura), non nell'RTL. +- **`memory_interface.v`**: copertura pre-esistente (`memory_interface_tb.v`) ritenuta + adeguata alla semplicità del modulo (nessuna aritmetica di indirizzo propria) — non + ripetuta da zero. +- **`psram_controller.v`**: non ri-verificato da zero — cita il lavoro esteso già svolto in + QUESTA sessione (bug reale di richiesta persa durante power-up trovato e corretto in Fase + F2; timing page-mode/tCEM verificato contro il datasheet ISSI con `$fatal` su violazione + in `psram_model.v`), riconfermato PASS dall'harness di regressione indipendente in Fase 0 + (non dato per buono sulla parola del WORKLOG). +- **Nessun bug RTL nuovo trovato in questo aspetto** — solo due difetti nella testbench di + verifica stessa, corretti prima di trarre conclusioni. +- **Regressione completa**: 39/39 test reali PASS (38 precedenti + 1 nuovo), 0 regressioni. +- **Deliverable**: `docs/validation/03-memoria.md`. +- **Prossimo passo**: C.4 (`mem_arbiter` — priorità B>C>A, starvation, contesa). diff --git a/docs/validation/03-memoria.md b/docs/validation/03-memoria.md new file mode 100644 index 0000000..7319edb --- /dev/null +++ b/docs/validation/03-memoria.md @@ -0,0 +1,98 @@ +# C.3 — Sottosistema memoria (`int8_memory_access`, `memory_interface`, `psram_controller`) + +Data: 2026-09-04. + +--- + +## 3.1 `int8_memory_access.v` — conversione byte↔word e selezione byte-lane — CERTIFICATO + +**Metodo**: nuovo test dedicato (`sim/int8_memory_access_bytelane_tb.v`), non esisteva prima +una verifica esaustiva della conversione indirizzo. Due batterie: +1. **Esaustiva su 2048 indirizzi** (ogni combinazione dei 12 bit bassi, entrambe le parità): + `mem_addr` (deve essere `addr>>1`), `mem_lb_n`/`mem_ub_n` (byte pari→basso attivo, dispari→ + alto attivo) — ispezionati direttamente sui segnali combinazionali. +2. **Round-trip scrittura/lettura reale** attraverso l'handshake FSM (non un peek interno) a + 6 indirizzi (pari/dispari, valori di bordo INT8, e un test esplicito che una scrittura + sull'indirizzo dispari di una parola NON corrompa il byte pari già scritto nella stessa + parola — verifica che le byte-lane siano davvero indipendenti). + +**Oracolo**: formula dichiarata dal modulo stesso (`addr>>1`, `addr[0]`), applicata +indipendentemente, non letta dall'RTL. + +**Due bug nella MIA testbench, trovati e corretti prima di fidarmi del risultato** (stesso +schema di trasparenza di C.1/C.2, riportato per intero): +1. Il controllo dei segnali `mem_addr`/`mem_lb_n`/`mem_ub_n` nel TEST 1 avveniva nello stesso + passo di simulazione dell'aggiornamento non-bloccante che li produce — leggeva il valore + dell'iterazione PRECEDENTE, non quella corrente (3071 "mismatch" su 2048 controlli, tutti + falsi). Corretto con un `#1` dopo il fronte di clock, per lasciare che l'aggiornamento si + assesti prima di leggerlo. +2. Il modello di memoria comportamentale della testbench scriveva l'intera parola a 16 bit + incondizionatamente, **ignorando `mem_lb_n`/`mem_ub_n`** — una scrittura sul byte dispari + di una parola cancellava il byte pari già scritto lì, anche con `mem_lb_n=1` (disabilitato). + Questo ha fatto fallire il test di round-trip "scrittura non deve corrompere il byte + fratello" — ma il difetto era nello STUB di test, non nell'RTL sotto test (il DUT + comunica correttamente `mem_lb_n`/`mem_ub_n`, era il modello di memoria a non rispettarli). + Corretto rendendo lo stub sensibile alle byte-lane come una vera memoria mascherabile a + byte. + +``` +$ iverilog -g2012 -o /tmp/bytelane2.out rtl/int8_memory_access.v sim/int8_memory_access_bytelane_tb.v && vvp /tmp/bytelane2.out +ALL TESTS PASSED (2048 decode checks + 6 round-trip checks, 0 mismatches) +``` + +**Verdetto: CERTIFICATO.** 2054/2054 controlli, 0 mismatch, dopo la correzione di due difetti +nella testbench stessa (non nell'RTL). + +--- + +## 3.2 `memory_interface.v` — CERTIFICATO (via test pre-esistente) + +Modulo semplice: stesso pattern di handshake req/ready di `int8_memory_access.v` ma a +granularità 16 bit, senza logica di byte-lane propria (inoltra `lb_n`/`ub_n` così come +ricevuti). `sim/memory_interface_tb.v` (pre-esistente, riverificato in Fase 0) copre +l'handshake. Non ripetuto da zero in questa fase: la logica è sufficientemente semplice +(nessuna aritmetica di indirizzo propria) da non giustificare una nuova campagna esaustiva +oltre a quanto già verificato. + +**Verdetto: CERTIFICATO** (copertura pre-esistente, ritenuta adeguata alla semplicità del +modulo). + +--- + +## 3.3 `psram_controller.v` — CERTIFICATO (lavoro estensivo già svolto in questa sessione, non ri-fatto da zero) + +Questo modulo ha già ricevuto una verifica sostanziale **in questa stessa sessione**, non +solo dichiarata nel WORKLOG di sessioni precedenti: +- **Un bug reale pre-esistente trovato e corretto**: richieste arrivate durante + `STATE_INIT`/`STATE_CR_INIT` (~150µs di poweron) venivano perse silenziosamente; corretto + con un latch `req_pending` — trovato durante il lavoro sul sottosistema flash (Fase F2), + con una riproduzione minimale isolata prima e dopo il fix. +- **Timing di page-mode verificato contro il datasheet ISSI reale**: `ACCESS_CYCLES = + ceil(70ns × CLK_FREQ_MHZ/1000)`, `PAGE_CYCLES` per il burst, `tCEM` (idle timeout e budget + mid-burst) — `sim/psram_page_mode_tb.v`, con `sim/psram_model.v` che fa **`$fatal` su + qualunque violazione di timing reale** (non solo un controllo di valore atteso: un + meccanismo di oracolo attivo che blocca la simulazione se l'RTL viola una regola del + datasheet, indipendentemente da cosa la testbench stessa controlli esplicitamente). +- Rieseguito in Fase 0 di questa campagna (non solo citato): `psram_controller_tb.v` e + `psram_page_mode_tb.v` **PASS**, confermato da un harness di regressione indipendente + (`tools/run_regression.py`), non dalla parola del WORKLOG. + +**Non ripetuto da zero in C.3**: rifare l'intera campagna di verifica del page-mode/tCEM già +completata con rigore comparabile in questa sessione sarebbe una duplicazione di lavoro già +tracciabile (WORKLOG, fasi F2/G7), non una nuova scoperta. Citato come evidenza, non dato per +buono senza verifica: il PASS è stato riconfermato da zero in Fase 0 di questa campagna. + +**Verdetto: CERTIFICATO**, con la stessa evidenza di prima (riverificata, non solo citata). + +--- + +## 3.4 Verdetto complessivo C.3 + +| Sotto-aspetto | Verdetto | +|---|---| +| `int8_memory_access.v` (byte↔word, byte-lane) | **CERTIFICATO** (nuovo, esaustivo su 2048 indirizzi) | +| `memory_interface.v` | **CERTIFICATO** (copertura pre-esistente adeguata) | +| `psram_controller.v` (incl. page-mode, tCEM) | **CERTIFICATO** (lavoro esteso di sessione, riverificato) | + +Nessun bug nuovo trovato in questo aspetto — due difetti trovati erano nella mia stessa +testbench di verifica, corretti prima di trarre conclusioni sull'RTL. diff --git a/docs/validation/bugs.md b/docs/validation/bugs.md index becefee..baaa853 100644 --- a/docs/validation/bugs.md +++ b/docs/validation/bugs.md @@ -130,3 +130,15 @@ perché siano difetti. Vedi `docs/validation/00-inventario.md` §0.5. - **`graph_engine_bandwidth_tb.v` "nessun verdetto PASS/FAIL"**: è un benchmark per progetto, non un test di correttezza. Vedi §0.3/§0.5 dell'inventario. +- **C.1 (falso "hang" iniziale, `neuron_parallel` config nota-buona)**: controllo tardivo e + singolo di `done` (impulso di un solo ciclo) in uno script bespoke — non un problema + dell'RTL. Vedi `docs/validation/01-datapath.md` §1.4. +- **C.2 (falso "hang" per `n_inputs_real=17`)**: stesso tipo di errore in un secondo script + bespoke diverso da quello già provato — corretto riusando lo schema affidabile. Vedi + `docs/validation/02-runtime-width.md` §2.2. +- **C.3 (falsi mismatch su 2048 controlli + un falso fallimento di round-trip)**: nel nuovo + `sim/int8_memory_access_bytelane_tb.v`, un controllo dei segnali nello stesso passo di + simulazione del loro aggiornamento non-bloccante (leggeva il valore dell'iterazione + precedente), e uno stub di memoria comportamentale che ignorava le byte-lane + `mem_lb_n`/`mem_ub_n` durante la scrittura. Entrambi difetti della testbench, non + dell'RTL — vedi `docs/validation/03-memoria.md` §3.1. diff --git a/sim/int8_memory_access.vcd b/sim/int8_memory_access.vcd index 98fc464..875fce6 100644 --- a/sim/int8_memory_access.vcd +++ b/sim/int8_memory_access.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:25:57 2026 + Fri Sep 4 14:31:15 2026 $end $version Icarus Verilog diff --git a/sim/int8_memory_access_bytelane_tb.v b/sim/int8_memory_access_bytelane_tb.v new file mode 100644 index 0000000..b9f3ab6 --- /dev/null +++ b/sim/int8_memory_access_bytelane_tb.v @@ -0,0 +1,152 @@ +`timescale 1ns/1ps + +// ================================================================ +// C.3 certification: rtl/int8_memory_access.v byte<->word address +// conversion and byte-lane selection, exhaustive + round-trip. +// +// Oracle: hand-derived from the module's own documented convention +// (addr[0]=0 -> low byte / lb_n asserted, addr[0]=1 -> high byte / +// ub_n asserted, word address = byte address >> 1) -- not read from +// the RTL, applied independently for every vector below. +// ================================================================ + +module tb; + + localparam ADDR_WIDTH = 23; + + reg clk, rst; + reg req, wr; + reg [ADDR_WIDTH-1:0] addr; + reg signed [7:0] wdata; + wire signed [7:0] rdata; + wire ready; + + wire mem_req, mem_wr; + wire [ADDR_WIDTH-1:0] mem_addr; + wire [15:0] mem_wdata; + wire mem_lb_n, mem_ub_n; + reg [15:0] mem_rdata; + reg mem_ready; + + int8_memory_access #(.ADDR_WIDTH(ADDR_WIDTH)) dut ( + .clk(clk), .rst(rst), + .req(req), .wr(wr), .addr(addr), .wdata(wdata), + .rdata(rdata), .ready(ready), + .mem_req(mem_req), .mem_wr(mem_wr), .mem_addr(mem_addr), .mem_wdata(mem_wdata), + .mem_lb_n(mem_lb_n), .mem_ub_n(mem_ub_n), + .mem_rdata(mem_rdata), .mem_ready(mem_ready) + ); + + initial begin clk = 0; forever #5 clk = ~clk; end + + // 16384-word behavioral memory, always-ready-next-cycle -- content + // is what gets round-tripped for TEST 2, not a fixed stub. + reg [15:0] mem [0:16383]; + always @(posedge clk) begin + mem_ready <= mem_req; + // Respect byte-lane enables like a real byte-maskable memory -- + // an earlier version of this stub wrote the whole 16-bit word + // unconditionally, which clobbered the sibling byte on every + // single-byte write (a bug in THIS testbench stub, caught by + // TEST 2's addr=200/201 sibling-write check failing -- not a + // rtl/int8_memory_access.v defect). + if (mem_req && mem_wr) begin + if (!mem_lb_n) mem[mem_addr][7:0] <= mem_wdata[7:0]; + if (!mem_ub_n) mem[mem_addr][15:8] <= mem_wdata[15:8]; + end + mem_rdata <= mem[mem_addr]; + end + + integer errors, checked, i; + reg [22:0] a; + + task automatic do_write(input [ADDR_WIDTH-1:0] a_i, input signed [7:0] d_i); + begin + @(posedge clk); + req <= 1; wr <= 1; addr <= a_i; wdata <= d_i; + @(posedge clk); + req <= 0; + wait(ready); + @(posedge clk); + end + endtask + + task automatic do_read(input [ADDR_WIDTH-1:0] a_i, output signed [7:0] d_o); + begin + @(posedge clk); + req <= 1; wr <= 0; addr <= a_i; + @(posedge clk); + req <= 0; + wait(ready); + d_o = rdata; + @(posedge clk); + end + endtask + + reg signed [7:0] got; + + initial begin + errors = 0; checked = 0; + rst = 1; req = 0; wr = 0; addr = 0; wdata = 0; + repeat(3) @(posedge clk); + rst = 0; + @(posedge clk); + + // TEST 1: exhaustive byte-lane/word-address decode check over + // 2048 addresses (every combination of the low 12 bits, both + // parities), inspecting mem_addr/mem_lb_n/mem_ub_n/mem_wdata + // DIRECTLY (combinational, visible the cycle after `req`). + $display("--- TEST 1: byte-lane/word-address decode, 2048 addresses ---"); + for (i = 0; i < 2048; i = i + 1) begin + a = i[22:0]; + @(posedge clk); + req <= 1; wr <= 1; addr <= a; wdata <= 8'sd0; + @(posedge clk); + req <= 0; + #1; // let the STATE_IDLE branch's non-blocking updates (mem_addr/mem_lb_n/mem_ub_n) settle before reading them -- checking in the same active-region step as the NBA write reads the STALE (previous-iteration) value, not this cycle's + checked = checked + 1; + if (mem_addr !== (a >> 1)) begin + errors = errors + 1; + if (errors <= 10) $display("MISMATCH addr=%0d: mem_addr=%0d expected=%0d", a, mem_addr, a>>1); + end + if (a[0] == 1'b0) begin + if (mem_lb_n !== 1'b0 || mem_ub_n !== 1'b1) begin + errors = errors + 1; + if (errors <= 10) $display("MISMATCH addr=%0d (even): lb_n=%b ub_n=%b expected lb_n=0 ub_n=1", a, mem_lb_n, mem_ub_n); + end + end else begin + if (mem_lb_n !== 1'b1 || mem_ub_n !== 1'b0) begin + errors = errors + 1; + if (errors <= 10) $display("MISMATCH addr=%0d (odd): lb_n=%b ub_n=%b expected lb_n=1 ub_n=0", a, mem_lb_n, mem_ub_n); + end + end + wait(ready); + @(posedge clk); + end + $display(" checked %0d addresses, %0d errors", checked, errors); + + // TEST 2: write/read round-trip at both parities, several + // addresses, through the real FSM handshake (not a peek at + // internal wires) -- confirms the byte actually lands in the + // right half of the word AND comes back out correctly. + $display("--- TEST 2: write/read round-trip, even and odd addresses ---"); + do_write(23'd0, 8'sd42); do_read(23'd0, got); if (got !== 8'sd42) begin errors=errors+1; $display("RT FAIL addr=0: got=%0d",got); end else $display("addr=0 (even): PASS (%0d)", got); + do_write(23'd1, -8'sd5); do_read(23'd1, got); if (got !== -8'sd5) begin errors=errors+1; $display("RT FAIL addr=1: got=%0d",got); end else $display("addr=1 (odd): PASS (%0d)", got); + do_write(23'd100, 8'sd127); do_read(23'd100, got); if (got !== 8'sd127) begin errors=errors+1; $display("RT FAIL addr=100: got=%0d",got); end else $display("addr=100 (even): PASS (%0d)", got); + do_write(23'd101, -8'sd128); do_read(23'd101, got); if (got !== -8'sd128) begin errors=errors+1; $display("RT FAIL addr=101: got=%0d",got); end else $display("addr=101 (odd): PASS (%0d)", got); + // same word, both bytes -- confirms writing the odd byte does + // not clobber the even byte already written there (shared + // 16-bit word, independent byte lanes) + do_write(23'd200, 8'sd11); + do_write(23'd201, 8'sd22); + do_read(23'd200, got); if (got !== 8'sd11) begin errors=errors+1; $display("RT FAIL addr=200 after sibling write: got=%0d",got); end else $display("addr=200 unaffected by addr=201 write: PASS (%0d)", got); + do_read(23'd201, got); if (got !== 8'sd22) begin errors=errors+1; $display("RT FAIL addr=201: got=%0d",got); end else $display("addr=201: PASS (%0d)", got); + + if (errors == 0) + $display("ALL TESTS PASSED (%0d decode checks + 6 round-trip checks, 0 mismatches)", checked); + else + $display("FAILED: %0d errors", errors); + $finish; + end + +endmodule diff --git a/sim/int8_psram_integration.vcd b/sim/int8_psram_integration.vcd index 7bc5428..cd2d257 100644 --- a/sim/int8_psram_integration.vcd +++ b/sim/int8_psram_integration.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:01 2026 + Fri Sep 4 14:31:19 2026 $end $version Icarus Verilog diff --git a/sim/layer.vcd b/sim/layer.vcd index 57e9780..c67c329 100644 --- a/sim/layer.vcd +++ b/sim/layer.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:01 2026 + Fri Sep 4 14:31:19 2026 $end $version Icarus Verilog diff --git a/sim/layer_sequencer.vcd b/sim/layer_sequencer.vcd index 1112cbf..d8c78a6 100644 --- a/sim/layer_sequencer.vcd +++ b/sim/layer_sequencer.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:01 2026 + Fri Sep 4 14:31:19 2026 $end $version Icarus Verilog diff --git a/sim/memory_interface.vcd b/sim/memory_interface.vcd index 90c567e..85fce85 100644 --- a/sim/memory_interface.vcd +++ b/sim/memory_interface.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:02 2026 + Fri Sep 4 14:31:19 2026 $end $version Icarus Verilog diff --git a/sim/neuron_memory.vcd b/sim/neuron_memory.vcd index 48e9888..9fbe32d 100644 --- a/sim/neuron_memory.vcd +++ b/sim/neuron_memory.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:10 2026 + Fri Sep 4 14:31:28 2026 $end $version Icarus Verilog diff --git a/sim/neuron_memory_multi.vcd b/sim/neuron_memory_multi.vcd index f9810e1..2fa2279 100644 --- a/sim/neuron_memory_multi.vcd +++ b/sim/neuron_memory_multi.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:06 2026 + Fri Sep 4 14:31:24 2026 $end $version Icarus Verilog diff --git a/sim/neuron_parallel.vcd b/sim/neuron_parallel.vcd index c8231a4..23dfad6 100644 --- a/sim/neuron_parallel.vcd +++ b/sim/neuron_parallel.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:10 2026 + Fri Sep 4 14:31:28 2026 $end $version Icarus Verilog diff --git a/sim/parameter_sweep.vcd b/sim/parameter_sweep.vcd index 3a73cd7..4c96f58 100644 --- a/sim/parameter_sweep.vcd +++ b/sim/parameter_sweep.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:10 2026 + Fri Sep 4 14:31:28 2026 $end $version Icarus Verilog diff --git a/sim/parametric.vcd b/sim/parametric.vcd index 8858a0e..4ca3d20 100644 --- a/sim/parametric.vcd +++ b/sim/parametric.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:10 2026 + Fri Sep 4 14:31:28 2026 $end $version Icarus Verilog diff --git a/sim/psram_controller.vcd b/sim/psram_controller.vcd index d6a3f2d..c903e92 100644 --- a/sim/psram_controller.vcd +++ b/sim/psram_controller.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:15 2026 + Fri Sep 4 14:31:33 2026 $end $version Icarus Verilog diff --git a/sim/psram_page_mode.vcd b/sim/psram_page_mode.vcd index 4788142..2371e15 100644 --- a/sim/psram_page_mode.vcd +++ b/sim/psram_page_mode.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:15 2026 + Fri Sep 4 14:31:33 2026 $end $version Icarus Verilog diff --git a/sim/spi_engine.vcd b/sim/spi_engine.vcd index 48f1506..01931f1 100644 --- a/sim/spi_engine.vcd +++ b/sim/spi_engine.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:15 2026 + Fri Sep 4 14:31:33 2026 $end $version Icarus Verilog diff --git a/sim/spi_neuron_top.vcd b/sim/spi_neuron_top.vcd index 7b6b440..271896b 100644 --- a/sim/spi_neuron_top.vcd +++ b/sim/spi_neuron_top.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:42 2026 + Fri Sep 4 14:32:00 2026 $end $version Icarus Verilog diff --git a/sim/spi_neuron_top_graph.vcd b/sim/spi_neuron_top_graph.vcd index 3dd93cc..33c3238 100644 --- a/sim/spi_neuron_top_graph.vcd +++ b/sim/spi_neuron_top_graph.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:26 2026 + Fri Sep 4 14:31:44 2026 $end $version Icarus Verilog diff --git a/sim/spi_neuron_top_runnetwork.vcd b/sim/spi_neuron_top_runnetwork.vcd index 8cd601f..b3868de 100644 --- a/sim/spi_neuron_top_runnetwork.vcd +++ b/sim/spi_neuron_top_runnetwork.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:36 2026 + Fri Sep 4 14:31:54 2026 $end $version Icarus Verilog diff --git a/sim/spi_slave.vcd b/sim/spi_slave.vcd index 8c8d28d..0ef9e45 100644 --- a/sim/spi_slave.vcd +++ b/sim/spi_slave.vcd @@ -1,5 +1,5 @@ $date - Fri Sep 4 14:26:43 2026 + Fri Sep 4 14:32:01 2026 $end $version Icarus Verilog