Simuler du RTL enregistré et conserver le résultat

Enregistrez une requête de simulation RTL bornée, soumettez-la à Admit et à Preflight, exécutez-la, puis enregistrez, listez et rouvrez le résultat dans votre projet.

Utilisez Altifigence CLI 0.1.9 sous Linux pour simuler du SystemVerilog enregistré avec le moteur RTL fourni. Les commandes de simulation admit, preflight et run lisent chacune un fichier de requête dans votre projet et affichent du JSON. Pour lire le contrat de simulation à quatre états et plusieurs horloges, exécutez alti rtl simulate-v2 capabilities.

Enregistrer une requête de simulation

Créez le dossier du projet et enregistrez-y cette requête sous sim.json. Utilisez exactement ces quatre clés de premier niveau. La requête contient le code source SystemVerilog, le port d’horloge et la période, un reset facultatif, les valeurs initiales des registres et un vecteur d’entrée par cycle.

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

Fournissez à chaque cycle chaque entrée de premier niveau, sauf l’horloge et le reset, en commençant par le bit de poids faible. Le moteur pilote l’horloge et active le reset pendant les assertCycles premiers cycles. Gardez clock.periodPs entre 2 et 1000000000. Définissez limits.maxCycles entre le nombre de cycles et 32768, et limits.maxTimePs entre cycles × periodPs et 1000000000000. Le fichier de requête peut atteindre 272629760 octets.

Vérifier la requête avant l’exécution

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"

Vérifiez que le code de sortie est 0 pour chaque commande. Admit vérifie la forme et les limites de la requête et renvoie altifigence.rtl.simulation-admission.v1 avec admitted à true ; pour cette requête, il indique cycleCount 4, transitionStepCount 8 et simulatedTimePs 4000. Preflight synthétise en outre le code source en une netlist logique et renvoie altifigence.rtl.simulation-preflight.v1 avec les ports d’entrée, les ports de sortie et les registres. La ligne jq affiche :

["q"]

Admit et Preflight sont des contrôles préalables. La simulation ne s’exécute qu’avec run.

Exécuter la simulation

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"

Vérifiez que le code de sortie est 0. Le résultat a le schéma altifigence.rtl.operation-result.v1 et l’operationId altifigence.rtl.simulate.v1. Son artefact est un reçu altifigence.rtl.simulation-receipt.v1 avec le preflight, une trace par pas d’événement, une forme d’onde VCD, un résumé et la provenance. Pour cette requête, la sortie finale est :

{"q":[false]}

Le moteur fourni synthétise le design et l’exécute avec son propre simulateur à deux états par pas d’événement. wave.vcd utilise l’échelle de temps 1ps.

Inspecter et synthétiser le fichier source

Enregistrez le même module comme fichier du projet, puis générez son schéma et synthétisez-le. Les chemins des fichiers source sont relatifs au projet.

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"

Vérifiez que le code de sortie est 0. La ligne jq affiche :

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

Le document contient aussi topModule, modules, instances, nets, connections, diagnostics et unsupported. Son status vaut complete ou partial ; un document failed se termine avec le code de sortie 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"

Vérifiez que le code de sortie est 0. Synth affiche la netlist logique et son rapport de synthèse. Pour ce module, la ligne jq affiche :

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

Si synth s’arrête avec alti-rtl: synth requires at least one SystemVerilog file, ajoutez après les options le chemin du fichier source, par exemple rtl/top.sv.

Conserver et rouvrir le résultat

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 valide le résultat complet et l’écrit sous .altifigence/artifacts/rtl/ dans le projet. Son manifeste altifigence.rtl.artifact-manifest.v1 contient entryId, le SHA-256 du résultat enregistré et relativePath results/<entryId>.json. List affiche chaque manifeste ; show affiche le JSON du résultat enregistré. Un résultat peut atteindre 67108864 octets.

Reprendre après des erreurs

Pour RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope, donnez au fichier exactement les clés schema, version, operationId et request avec les valeurs indiquées ci-dessus.

Pour RTL simulation request must be a normalized project-relative path, transmettez le chemin relatif au projet, par exemple sim.json, sans ./ ni / au début.

Le moteur affiche les erreurs de requête après alti-rtl: et se termine avec le code de sortie 2. Pour RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4, portez limits.maxCycles au nombre de cycles et relancez admit.

Pour RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000, portez limits.maxTimePs à au moins le nombre de cycles × clock.periodPs.

Pour RTL artifact entry does not exist: suivi d’un ID, copiez un entryId depuis alti rtl artifact list et relancez show.

Vérifier et analyser les sources enregistrées

Utilisez le fichier rtl/top.sv enregistré de la section précédente. Vérifiez ses diagnostics, examinez la couverture du vérificateur et la hiérarchie, puis lisez l’analyse native des symboles. Placez les options d’exécution après la sous-commande du compilateur.

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

La forme compatible synthesize exécute également le synthétiseur local. Transmettez ses arguments de moteur après -- :

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

Pour RTL compiler execution options must follow the explicit subcommand, placez --runner local et --project après check, coverage ou hierarchy, comme indiqué ci-dessus.

Associer une netlist combinatoire à des cellules

Enregistrez un exemple combinatoire distinct et une petite bibliothèque Liberty. Synthétisez sa netlist, puis associez chaque cellule logique à une cellule de bibliothèque de fonction équivalente.

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

Pour no direct Liberty cell covers generic kind suivi d’un type de cellule, fournissez une bibliothèque contenant la fonction booléenne correspondante et une valeur area positive, puis relancez la commande d’association.

Vérifier une sélection de cible et ses sources

Lisez le contrat d’analyse de cible et l’enregistrement de disponibilité, puis vérifiez un paquet de sources. L’admission enregistre vos sélections et l’empreinte des sources. Le contrôle préalable structurel renvoie les diagnostics, la couverture et la hiérarchie.

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 est la sélection de profil enregistrée par cet exemple. Conservez tops égal au --top demandé. Pour target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid, vérifiez que sources et roots contiennent la source et que tops contient cet unique nom de module de tête.

Exécuter le contrat de simulation à quatre états

Réutilisez la source dans sim.json avec une requête temporisée à quatre états. Les valeurs sont les chaînes 0, 1, X et Z, avec le bit de poids faible en premier. Cet exemple utilise une horloge, une remise à zéro et un calendrier d’entrées temporisé.

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

Vérifiez que le code de sortie est 0 à chaque étape. L’admission vérifie la requête temporisée ; le contrôle préalable prépare sa netlist synthétisée ; l’exécution produit la trace, la forme d’onde, le résumé et la provenance. Utilisez une valeur paire pour periodPs et une valeur phasePs inférieure à la période.

Commandes CLI des moteurs