Simulare RTL salvato e conservare il risultato

Salva una richiesta di simulazione RTL limitata, esegui admit e preflight, eseguila, quindi salva, elenca e riapri il risultato nel tuo progetto.

Utilizza Altifigence CLI 0.1.9 su Linux per simulare SystemVerilog salvato con il motore RTL incluso. I comandi di simulazione admit, preflight e run leggono ciascuno un file di richiesta nel progetto e stampano JSON. Per leggere il contratto di simulazione a quattro stati con più clock, esegui alti rtl simulate-v2 capabilities.

Salvare una richiesta di simulazione

Crea la cartella del progetto e salva al suo interno questa richiesta come sim.json. Utilizza esattamente queste quattro chiavi di primo livello. La richiesta contiene il sorgente SystemVerilog, la porta e il periodo del clock, un reset facoltativo, i valori iniziali dei registri e un vettore di ingresso per ciclo.

mkdir -p "$HOME/alti-projects/demo-project"
PROJECT="$(cd "$HOME/alti-projects/demo-project" && pwd -P)"

{
  "schema": "altifigence.rtl.operation-request.v1",
  "version": 1,
  "operationId": "altifigence.rtl.simulate.v1",
  "request": {
    "top": "top",
    "sources": [
      {
        "path": "workspace/top.sv",
        "source": "module top(\n  input logic clk,\n  input logic rst,\n  input logic d,\n  output logic q\n);\n  always_ff @(posedge clk or posedge rst)\n    if (rst) q <= 1'b0;\n    else q <= d;\nendmodule\n"
      }
    ],
    "clock": {
      "port": "clk",
      "periodPs": 1000
    },
    "initialRegisterValues": [
      false
    ],
    "cycles": [
      {
        "inputs": {
          "d": [
            false
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            false
          ]
        }
      }
    ],
    "limits": {
      "maxCycles": 4,
      "maxTimePs": 4000
    },
    "reset": {
      "port": "rst",
      "activeLevel": "active_high",
      "assertCycles": 1
    }
  }
}

Fornisci in ogni ciclo ogni ingresso di primo livello tranne il clock e il reset, con il bit meno significativo per primo. Il motore pilota il clock e attiva il reset per i primi assertCycles cicli. Mantieni clock.periodPs da 2 a 1000000000. Imposta limits.maxCycles dal numero di cicli fino a 32768 e limits.maxTimePs da cicli × periodPs fino a 1000000000000. Il file di richiesta può avere fino a 272629760 byte.

Controllare la richiesta prima dell’esecuzione

alti rtl simulate admit --project "$PROJECT" sim.json
alti rtl simulate preflight --project "$PROJECT" sim.json > "$PROJECT/preflight.json"
jq -c '[.outputPorts[].name]' "$PROJECT/preflight.json"

Verifica che il codice di uscita sia 0 per ogni comando. Admit controlla la forma e i limiti della richiesta e restituisce altifigence.rtl.simulation-admission.v1 con admitted true; per questa richiesta riporta cycleCount 4, transitionStepCount 8 e simulatedTimePs 4000. Preflight sintetizza inoltre il sorgente in una netlist logica e restituisce altifigence.rtl.simulation-preflight.v1 con le porte di ingresso, le porte di uscita e i registri. La riga jq stampa:

["q"]

Admit e preflight sono controlli preliminari. La simulazione viene eseguita solo con run.

Eseguire la simulazione

alti rtl simulate run --project "$PROJECT" sim.json > "$PROJECT/result.json"
jq -c '.artifact.payload.summaryArtifact.payload.finalOutputsLsb0' "$PROJECT/result.json"
jq -r '.artifact.payload.waveformArtifact.payload' "$PROJECT/result.json" > "$PROJECT/wave.vcd"

Verifica che il codice di uscita sia 0. Il risultato ha lo schema altifigence.rtl.operation-result.v1 e operationId altifigence.rtl.simulate.v1. Il suo artefatto è una ricevuta altifigence.rtl.simulation-receipt.v1 con il preflight, una traccia a passi di evento, una forma d’onda VCD, un riepilogo e la provenienza. Per questa richiesta l’output finale è:

{"q":[false]}

Il motore incluso sintetizza il design e lo esegue con il proprio simulatore a due stati a passi di evento. wave.vcd utilizza un timescale 1ps.

Ispezionare e sintetizzare il sorgente

Salva lo stesso modulo come file del progetto, quindi genera il suo schematic e sintetizzalo. I percorsi dei file sorgente sono relativi al progetto.

mkdir -p "$PROJECT/rtl"
jq -r '.request.sources[0].source' "$PROJECT/sim.json" > "$PROJECT/rtl/top.sv"
alti rtl schematic --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/schematic.json"
jq -c '{schema, source}' "$PROJECT/schematic.json"

Verifica che il codice di uscita sia 0. La riga jq stampa:

{"schema":"alti-rtl-schematic.v1","source":"saved-files"}

Il documento contiene anche topModule, modules, instances, nets, connections, diagnostics e unsupported. Il suo status è complete o partial; un documento failed termina con codice di uscita 1.

alti rtl synth --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/synth.json"
jq -c '{report: .report.schema, netlist: .netlist.schema, cells: .report.stats.cells_by_kind}' "$PROJECT/synth.json"

Verifica che il codice di uscita sia 0. Synth stampa la netlist logica e il relativo report di sintesi. Per questo modulo la riga jq stampa:

{"report":"rtl-synth-report-2","netlist":"logic-netlist-2","cells":{"dff_posedge_async_reset":1}}

Se synth si interrompe con alti-rtl: synth requires at least one SystemVerilog file, aggiungi il percorso del file sorgente, ad esempio rtl/top.sv, dopo le opzioni.

Conservare e riaprire il risultato

alti rtl artifact store --project "$PROJECT" result.json > "$PROJECT/manifest.json"
ENTRY_ID="$(jq -r '.entryId' "$PROJECT/manifest.json")"
alti rtl artifact list --project "$PROJECT"
alti rtl artifact show --project "$PROJECT" "$ENTRY_ID" > "$PROJECT/reopened.json"

Store convalida il risultato completo e lo scrive sotto .altifigence/artifacts/rtl/ nel progetto. Il suo manifest altifigence.rtl.artifact-manifest.v1 contiene entryId, lo SHA-256 del risultato salvato, e relativePath results/<entryId>.json. List stampa ogni manifest; show stampa il JSON del risultato salvato. Un risultato può avere fino a 67108864 byte.

Riprendere dopo gli errori

Per RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope, assegna al file esattamente le chiavi schema, version, operationId e request con i valori mostrati sopra.

Per RTL simulation request must be a normalized project-relative path, passa il percorso relativo al progetto, ad esempio sim.json, senza un ./ o un / iniziale.

Il motore stampa gli errori della richiesta dopo alti-rtl: e termina con codice di uscita 2. Per RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4, aumenta limits.maxCycles al numero di cicli ed esegui di nuovo admit.

Per RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000, aumenta limits.maxTimePs ad almeno il numero di cicli × clock.periodPs.

Per RTL artifact entry does not exist: seguito da un id, copia un entryId da alti rtl artifact list ed esegui di nuovo show.

Verificare e analizzare le sorgenti salvate

Utilizza il file rtl/top.sv salvato nella sezione precedente. Controlla la diagnostica, esamina la copertura del verificatore e la gerarchia, quindi leggi l’analisi nativa dei simboli. Inserisci le opzioni di esecuzione dopo il sottocomando del compilatore.

alti rtl compile check --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile coverage --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile hierarchy --runner local --project "$PROJECT" -- rtl/top.sv --top top --format json
alti rtl analysis --project "$PROJECT" rtl/top.sv > "$PROJECT/analysis.json"
jq -c '{schemaVersion}' "$PROJECT/analysis.json"

{"schemaVersion":"sv-symbols.v2"}

Anche la forma compatibile synthesize esegue il sintetizzatore locale. Passa gli argomenti del motore dopo --:

alti rtl synthesize --runner local --project "$PROJECT" -- --top top rtl/top.sv > "$PROJECT/synth-compat.json"

Per RTL compiler execution options must follow the explicit subcommand, inserisci --runner local e --project dopo check, coverage o hierarchy, come mostrato sopra.

Mappare una netlist combinatoria su celle

Salva un esempio combinatorio separato e una piccola libreria Liberty. Sintetizza la sua netlist, quindi mappa ogni cella logica su una cella di libreria con funzione equivalente.

cat > "$PROJECT/rtl/map-example.sv" <<'SV'
module top(input logic a, input logic b, output logic y);
  logic n;
  assign n = a & b;
  assign y = ~n;
endmodule
SV
cat > "$PROJECT/map-example.lib" <<'LIB'
library (neutral) {
  cell (AND2) {
    area : 2.0;
    pin (A) { direction : input; }
    pin (B) { direction : input; }
    pin (Y) { direction : output; function : "A & B"; }
  }
  cell (INV) {
    area : 1.0;
    pin (A) { direction : input; }
    pin (Y) { direction : output; function : "!A"; }
  }
}
LIB
alti rtl synth --project "$PROJECT" --top top --netlist-only rtl/map-example.sv > "$PROJECT/map-netlist.json"
alti rtl map --project "$PROJECT" --netlist map-netlist.json --liberty map-example.lib > "$PROJECT/map-report.json"
jq -c '{schema, mapped_cell_count, total_area}' "$PROJECT/map-report.json"

{"schema":"rtl-liberty-direct-map-report-0","mapped_cell_count":2,"total_area":"3.0"}

Per no direct Liberty cell covers generic kind seguito da un tipo di cella, fornisci una libreria con la funzione booleana corrispondente e un valore positivo di area, quindi esegui di nuovo il comando di mappatura.

Verificare una selezione di destinazione e le sue sorgenti

Leggi il contratto di analisi della destinazione e il record di disponibilità, quindi verifica un pacchetto di sorgenti. L’ammissione registra le selezioni e il digest delle sorgenti. Il controllo preliminare strutturale restituisce diagnostica, copertura e gerarchia.

alti rtl target-analysis capabilities
alti rtl target-analysis readiness
jq '{schema:"rtl-source-bundle.v1",sources:[.request.sources[] | {path,text:.source}],roots:[.request.sources[].path],include_dirs:[],defines:[],tops:[.request.top]}' "$PROJECT/sim.json" > "$PROJECT/target-sources.json"
DEADLINE_MS="$(( $(date +%s) * 1000 + 60000 ))"
TARGET_ARGS=(--module top --top top --targets generic-asic --primary-target generic-asic
  --tools schematic,evidence --report-detail standard --profile local-example
  --cpu-slots 1 --memory-bytes 536870912 --max-wall-time-ms 5000
  --deadline-unix-ms "$DEADLINE_MS")
alti rtl target-analysis admit "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-admission.json"
jq -c '{schema, structuralPreflightAvailable}' "$PROJECT/target-admission.json"
alti rtl target-analysis preflight "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-preflight.json"
jq -r '.schema' "$PROJECT/target-preflight.json"

{"schema":"altifigence.rtl.target-analysis-direct-admission.v1","structuralPreflightAvailable":true}
altifigence.rtl.target-analysis-direct-result.v1

local-example è la selezione del profilo registrata da questo esempio. Mantieni tops uguale al --top richiesto. Per target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid, verifica che sources e roots contengano la sorgente e che tops contenga quell’unico nome di modulo principale.

Eseguire il contratto di simulazione a quattro stati

Riutilizza la sorgente in sim.json con una richiesta temporizzata a quattro stati. I valori sono le stringhe 0, 1, X e Z, con il bit meno significativo per primo. Questo esempio utilizza un clock, un reset e una pianificazione temporizzata degli ingressi.

jq '{schema:.schema,version:1,operationId:"altifigence.rtl.simulate.v2",request:{
  top:.request.top,sources:.request.sources,
  clocks:[{port:"clk",periodPs:1000,phasePs:500}],
  resets:[{port:"rst",activeLevel:"active_high",changes:[
    {timePs:0,valueLsb0:["1"]},{timePs:1000,valueLsb0:["0"]}]}],
  inputSchedules:[{port:"d",changes:[
    {timePs:0,valueLsb0:["0"]},{timePs:1000,valueLsb0:["1"]}]}],
  initialRegisterValues:["0"],
  limits:{maxCyclesPerClock:4,maxTimePs:4000,maxEvents:64}
}}' "$PROJECT/sim.json" > "$PROJECT/sim-v2.json"
alti rtl simulate-v2 admit --project "$PROJECT" sim-v2.json > "$PROJECT/v2-admission.json"
alti rtl simulate-v2 preflight --project "$PROJECT" sim-v2.json > "$PROJECT/v2-preflight.json"
alti rtl simulate-v2 run --project "$PROJECT" sim-v2.json > "$PROJECT/v2-result.json"
jq -r '.schema' "$PROJECT/v2-admission.json" "$PROJECT/v2-preflight.json"
jq -r '.artifact.payload.schema' "$PROJECT/v2-result.json"

altifigence.rtl.simulation-admission.v2
altifigence.rtl.simulation-preflight.v2
altifigence.rtl.simulation-receipt.v2

Verifica che il codice di uscita sia 0 a ogni passaggio. L’ammissione verifica la richiesta temporizzata; il controllo preliminare prepara la netlist sintetizzata; l’esecuzione produce traccia, forma d’onda, riepilogo e provenienza. Utilizza un valore pari di periodPs e un valore di phasePs inferiore al periodo.

Comandi dei motori CLI