Gespeichertes RTL simulieren und das Ergebnis aufbewahren

Speichern Sie eine begrenzte RTL-Simulationsanfrage, prüfen Sie sie mit Admit und Preflight, führen Sie sie aus, speichern Sie das Ergebnis dann in Ihrem Projekt, listen Sie es auf und öffnen Sie es erneut.

Verwenden Sie Altifigence CLI 0.1.9 unter Linux, um gespeichertes SystemVerilog mit der mitgelieferten RTL-Engine zu simulieren. Die Simulationsbefehle admit, preflight und run lesen jeweils eine Anfragedatei in Ihrem Projekt und geben JSON aus. Führen Sie alti rtl simulate-v2 capabilities aus, um den Vertrag für die Vierzustandssimulation mit mehreren Takten zu lesen.

Eine Simulationsanfrage speichern

Erstellen Sie den Projektordner und speichern Sie diese Anfrage darin als sim.json. Verwenden Sie genau diese vier Schlüssel auf oberster Ebene. Die Anfrage enthält den SystemVerilog-Quelltext, den Takt-Port und die Taktperiode, einen optionalen Reset, die Anfangswerte der Register und einen Eingabevektor pro Zyklus.

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

Geben Sie in jedem Zyklus jeden Eingang der obersten Ebene außer Takt und Reset an, mit dem niederwertigsten Bit zuerst. Die Engine treibt den Takt und aktiviert den Reset in den ersten assertCycles Zyklen. Halten Sie clock.periodPs im Bereich von 2 bis 1000000000. Setzen Sie limits.maxCycles auf einen Wert zwischen der Anzahl der Zyklen und 32768 und limits.maxTimePs auf einen Wert zwischen Zyklen × periodPs und 1000000000000. Die Anfragedatei darf bis zu 272629760 Bytes groß sein.

Die Anfrage vor der Ausführung prüfen

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"

Prüfen Sie bei jedem Befehl, dass der Exit-Status 0 ist. Admit prüft Form und Grenzen der Anfrage und gibt altifigence.rtl.simulation-admission.v1 mit admitted gleich true zurück; für diese Anfrage meldet es cycleCount 4, transitionStepCount 8 und simulatedTimePs 4000. Preflight synthetisiert außerdem den Quelltext zu einer Logik-Netzliste und gibt altifigence.rtl.simulation-preflight.v1 mit den Eingangsports, Ausgangsports und Registern zurück. Die jq-Zeile gibt aus:

["q"]

Admit und Preflight sind Vorabprüfungen. Die Simulation läuft nur mit run.

Die Simulation ausführen

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"

Prüfen Sie, dass der Exit-Status 0 ist. Das Ergebnis hat das Schema altifigence.rtl.operation-result.v1 und die operationId altifigence.rtl.simulate.v1. Sein Artefakt ist ein altifigence.rtl.simulation-receipt.v1-Beleg mit dem Preflight, einem Ereignisschritt-Trace, einer VCD-Wellenform, einer Zusammenfassung und der Herkunft. Für diese Anfrage ist die endgültige Ausgabe:

{"q":[false]}

Die mitgelieferte Engine synthetisiert das Design und führt es mit ihrem eigenen Zwei-Zustands-Ereignisschritt-Simulator aus. wave.vcd verwendet die Zeitskala 1ps.

Die Quelldatei untersuchen und synthetisieren

Speichern Sie dasselbe Modul als Projektdatei, erzeugen Sie dann seinen Schaltplan und synthetisieren Sie es. Pfade von Quelldateien sind relativ zum Projekt.

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"

Prüfen Sie, dass der Exit-Status 0 ist. Die jq-Zeile gibt aus:

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

Das Dokument enthält außerdem topModule, modules, instances, nets, connections, diagnostics und unsupported. Sein status ist complete oder partial; bei einem failed-Dokument endet der Befehl mit dem Exit-Status 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"

Prüfen Sie, dass der Exit-Status 0 ist. Synth gibt die Logik-Netzliste und deren Synthesebericht aus. Für dieses Modul gibt die jq-Zeile aus:

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

Wenn synth mit alti-rtl: synth requires at least one SystemVerilog file abbricht, fügen Sie nach den Optionen den Pfad der Quelldatei hinzu, etwa rtl/top.sv.

Das Ergebnis aufbewahren und erneut öffnen

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 validiert das vollständige Ergebnis und schreibt es im Projekt unter .altifigence/artifacts/rtl/. Das zugehörige Manifest altifigence.rtl.artifact-manifest.v1 enthält entryId, den SHA-256-Wert des gespeicherten Ergebnisses und relativePath results/<entryId>.json. List gibt jedes Manifest aus; show gibt das JSON des gespeicherten Ergebnisses aus. Ein Ergebnis darf bis zu 67108864 Bytes groß sein.

Nach Fehlern fortfahren

Bei RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope versehen Sie die Datei mit genau den Schlüsseln schema, version, operationId und request und den oben gezeigten Werten.

Bei RTL simulation request must be a normalized project-relative path übergeben Sie den Pfad relativ zum Projekt, etwa sim.json, ohne führendes ./ oder /.

Die Engine gibt Anfragefehler nach alti-rtl: aus und beendet sich mit dem Exit-Status 2. Bei RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4 erhöhen Sie limits.maxCycles auf die Anzahl der Zyklen und führen Sie admit erneut aus.

Bei RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000 erhöhen Sie limits.maxTimePs auf mindestens die Anzahl der Zyklen × clock.periodPs.

Bei RTL artifact entry does not exist: gefolgt von einer ID kopieren Sie eine entryId aus alti rtl artifact list und führen show erneut aus.

Gespeicherte Quellen prüfen und analysieren

Verwenden Sie die gespeicherte Datei rtl/top.sv aus dem vorherigen Abschnitt. Prüfen Sie ihre Diagnosen, sehen Sie sich Prüfabdeckung und Hierarchie an und lesen Sie danach die native Symbolanalyse. Setzen Sie Ausführungsoptionen hinter den Compiler-Unterbefehl.

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"}

Die kompatible Schreibweise synthesize führt ebenfalls den lokalen Synthesizer aus. Übergeben Sie seine Engine-Argumente nach --:

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

Setzen Sie bei RTL compiler execution options must follow the explicit subcommand die Optionen --runner local und --project hinter check, coverage oder hierarchy, wie oben gezeigt.

Eine kombinatorische Netzliste auf Zellen abbilden

Speichern Sie ein separates kombinatorisches Beispiel und eine kleine Liberty-Bibliothek. Synthetisieren Sie dessen Netzliste und bilden Sie anschließend jede Logikzelle auf eine funktionsgleiche Bibliothekszelle ab.

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"}

Wenn auf no direct Liberty cell covers generic kind ein Zelltyp folgt, stellen Sie eine Bibliothek mit der passenden booleschen Funktion und einem positiven Wert für area bereit. Führen Sie den Mapping-Befehl danach erneut aus.

Eine Zielauswahl und ihre Quellen prüfen

Lesen Sie den Vertrag und den Bereitschaftsdatensatz der Zielanalyse und prüfen Sie anschließend ein Quellpaket. Die Zulassung erfasst Ihre Auswahl und den Quelldigest. Die strukturelle Vorprüfung gibt Diagnosen, Abdeckungs- und Hierarchieprodukte zurück.

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 ist die in diesem Beispiel erfasste Profilauswahl. Halten Sie tops mit dem angeforderten --top identisch. Prüfen Sie bei target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid, ob sources und roots die Quelle und tops genau diesen einen Top-Namen enthalten.

Den Vertrag für die Vierzustandssimulation ausführen

Verwenden Sie die Quelle in sim.json erneut mit einer zeitgesteuerten Vierzustandsanfrage. Die Werte sind die Zeichenfolgen 0, 1, X und Z, mit dem niederwertigsten Bit zuerst. Dieses Beispiel verwendet einen Takt, einen Reset und einen zeitgesteuerten Eingabeplan.

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

Prüfen Sie bei jedem Schritt, dass der Exit-Status 0 ist. Die Zulassung prüft die zeitgesteuerte Anfrage, die Vorprüfung bereitet ihre synthetisierte Netzliste vor und die Ausführung erzeugt Trace, Wellenform, Zusammenfassung und Herkunftsnachweis. Verwenden Sie einen geraden Wert für periodPs und einen Wert für phasePs, der kleiner als die Periode ist.

CLI-Engine-Befehle