Statisches Timing und FDTD2D mit alti px auf der CPU ausführen

Fragen Sie PX-Operationen ab, führen Sie statisches Timing mit einer Projekteingabe aus, bewahren Sie das Ergebnis auf, öffnen Sie es erneut und führen Sie das FDTD2D-Fixture auf der CPU aus.

Verwenden Sie Altifigence CLI 0.1.9 unter Linux, um PX-Operationen auf Dateien im Ordner inputs/ Ihres Projekts auszuführen. Beginnen Sie mit den Abfragen der Fähigkeiten, führen Sie statisches Timing mit einem einzigen Takt aus, bewahren Sie das Ergebnis im Artefaktspeicher des Projekts auf und führen Sie das integrierte FDTD2D-Fixture mit dem CPU-Backend aus.

PX-Operationen abfragen

Lesen Sie die installierten PX-Dokumente zu den Fähigkeiten. Diese Befehle sind Abfragen: Sie geben ein JSON-Dokument aus und führen keinen Job aus. alti px fdtd2d readiness meldet die Bereitschaft des installierten FDTD2D, ohne eine CPU-Lease zu belegen.

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

Prüfen Sie bei jedem Befehl, dass der Exit-Status 0 ist.

Statisches Timing ausführen

Verwenden Sie einen absoluten Pfad zu Ihrem lokalen Projekt und führen Sie die Befehle mit Ihrem normalen Benutzerkonto aus. PX liest Eingabedateien aus dem Ordner inputs/ des Projekts. Übergeben Sie den Dateinamen relativ zu inputs/.

set -euo pipefail
PROJECT="$(cd "$HOME/alti-projects/demo-project" && pwd -P)"
WORK="$(mktemp -d)"
mkdir -p "$PROJECT/inputs"
cat > "$PROJECT/inputs/timing.json" <<'JSON'
{
  "schema": "altifigence.px.static-timing-request.v1",
  "version": 1,
  "delayModel": "explicit_arc_min_max",
  "cornerModel": "single_caller_resolved",
  "libraryModel": "none",
  "graph": {
    "nodeIds": ["in", "mid", "out"],
    "sourceNodeId": "in",
    "sourceMinArrivalNs": 0.0,
    "sourceMaxArrivalNs": 0.0,
    "arcs": [
      {"id": "a1", "fromNodeId": "in", "toNodeId": "mid", "minDelayNs": 0.1, "maxDelayNs": 0.2},
      {"id": "a2", "fromNodeId": "mid", "toNodeId": "out", "minDelayNs": 0.3, "maxDelayNs": 0.4}
    ]
  },
  "constraints": {
    "clockPeriodNs": 1.0,
    "setupTimeNs": 0.05,
    "holdTimeNs": 0.02,
    "setupMarginNs": 0.0,
    "holdMarginNs": 0.0
  }
}
JSON

Die Anfrage nennt für jede Kante eine ausdrückliche minimale und maximale Verzögerung in Nanosekunden sowie einen Quellknoten und einen idealen Takt mit Setup- und Hold-Bedingungen. Halten Sie Knoten-IDs und Kanten-IDs eindeutig und lassen Sie jede Kante auf aufgeführte Knoten zeigen. Eine Anfrage enthält bis zu 65536 Knoten und 131072 Kanten innerhalb von 4194304 Bytes.

alti px static-timing --project "$PROJECT" timing.json > "$WORK/timing.json"
jq '{schema, operationId}' "$WORK/timing.json"

Prüfen Sie, dass der Exit-Status 0 ist. Die ausgewählten Felder lauten:

{
  "schema": "altifigence.px.operation-result.v1",
  "operationId": "altifigence.px.static-timing.v1"
}

Das Ergebnis enthält einen Bericht altifigence.px.static-timing-report.v1 mit authority non_signoff, den Ankunftszeiten und Slack-Werten für jeden Knoten sowie den Hashwerten von Artefakt, Eingabe und Anfrage.

Ergebnisse aufbewahren und erneut öffnen

Speichern Sie das Ergebnis des statischen Timings im PX-Artefaktspeicher des Projekts, listen Sie dann die gespeicherten Einträge auf und öffnen Sie den Eintrag über seine ID erneut.

alti px artifact store --project "$PROJECT" "$WORK/timing.json" > "$WORK/entry.json"
jq '{schema, entryId}' "$WORK/entry.json"
ENTRY="$(jq -r .entryId "$WORK/entry.json")"
alti px artifact list --project "$PROJECT" | jq -r '.[].entryId'
alti px artifact show --project "$PROJECT" "$ENTRY" > "$WORK/shown.json"
jq '{schema, operationId}' "$WORK/shown.json"

Prüfen Sie bei jedem Befehl, dass der Exit-Status 0 ist. Beim Speichern wird ein Manifest mit dem Schema altifigence.px.artifact-manifest.v1 geschrieben. Dessen entryId ist ein aus 64 Zeichen bestehender SHA-256-Wert in Kleinbuchstaben, und der Eintrag wird im Projekt unter .altifigence/artifacts/px aufbewahrt. alti px artifact show validiert das gespeicherte Ergebnis erneut und gibt es mit dem Schema altifigence.px.operation-result.v1 wieder aus.

Das FDTD2D-Fixture auf der CPU ausführen

Speichern Sie die Anfrage des integrierten FDTD2D-Fixtures unterhalb von inputs/ und führen Sie sie mit dem CPU-Backend aus.

cat > "$PROJECT/inputs/fdtd2d.json" <<'JSON'
{
  "schema": "altifigence.px.fdtd2d-execute-request.v1",
  "fixtureId": "px.fdtd2d.owned-pattern-19x13-96.v1"
}
JSON
alti px fdtd2d execute --backend cpu --project "$PROJECT" \
  fdtd2d.json > "$WORK/fdtd2d.json"
jq -r .schema "$WORK/fdtd2d.json"

Prüfen Sie, dass der Exit-Status 0 ist. Das Schema des Belegs ist altifigence.px.fdtd2d-execute-receipt.v1. Begrenzen Sie die Anfrage auf 4096 Bytes. Die CPU-Ausführung ist deterministisch: Eine erneute Ausführung derselben Anfrage gibt denselben Beleg aus.

Nach PX-Fehlern fortfahren

Bei Fehlern der Engine static-timing lesen Sie die JSON-Fehlerzeile auf stderr. Sie enthält das Schema altifigence.localRunner.error.v1, eine Kategorie und eine Meldung.

Wenn stderr diese Zeile meldet, konnte die Eingabedatei am angegebenen Pfad unterhalb von inputs/ nicht gelesen werden:

{"schema":"altifigence.localRunner.error.v1","category":"input_io","message":"failed to read job input"}

Speichern Sie die Datei in $PROJECT/inputs/ und übergeben Sie ihren Pfad relativ zu inputs/, zum Beispiel timing.json.

Wenn stderr diese Zeile meldet, entspricht die Anfrage nicht ihrem Schema:

{"schema":"altifigence.localRunner.error.v1","category":"invalid_job","message":"job input is not an admitted PX operation"}

Verwenden Sie für die statische Timing-Analyse die Felder, Version 1, das Schema und die Graphregeln der obigen Timing-Anfrage. Führen Sie den Befehl danach erneut aus. Verwenden Sie für FDTD2D das Schema und fixtureId der Fixture-Anfrage.

Wenn der Befehl für alti px fdtd2d execute diesen Fehler ausgibt, ist der Eingabepfad kein einfacher Pfad unterhalb von inputs/:

PX numerical input must be a file below workspace inputs/

Übergeben Sie den Pfad relativ zu inputs/ mit / als Trennzeichen und ohne leere Segmente und ohne die Segmente . oder .., zum Beispiel fdtd2d.json.

Ein Prozessrezept kompilieren

Speichern Sie einen Oxidationsschritt als inputs/recipe.json. Führen Sie process-recipe aus, um das Rezept zu validieren und seinen Plan in der Deklarationsreihenfolge zu kompilieren. Speichern Sie das Operationsergebnis mit denselben Artifact-Store-Befehlen wie das Timing-Ergebnis.

cat > "$PROJECT/inputs/recipe.json" <<'JSON'
{"schema":"px-recipe-1","name":"oxide","wafer":{"substrate_doping_cm3":1000000000000000,"depth_um":0.25,"mesh_nodes":51},"steps":[{"kind":"oxidation","label":"oxide","params":{"ambient":"dry","temp_c":1000,"time_s":10,"pressure_atm":1,"initial_oxide_nm":0}}]}
JSON
alti px process-recipe --project "$PROJECT" recipe.json > "$WORK/recipe-result.json"
jq '{operationId, steps: .artifact.payload.stepCount}' "$WORK/recipe-result.json"

{"operationId":"altifigence.px.process-recipe.v1","steps":1}

Vergleichen Sie bei invalid_job die Datei mit dem Beispiel: Verwenden Sie das Schema px-recipe-1, das kleingeschriebene oxidation und die aufgeführten Wafer- und Schrittfelder. Korrigieren Sie die Datei und führen Sie process-recipe erneut aus.

SPEF zusammenfassen und analysieren

Speichern Sie den folgenden SPEF-Inhalt als inputs/synthetic.spef. Die Zusammenfassung enthält die extrahierten Widerstände und Kondensatoren. Speichern Sie die Konfiguration als inputs/spef-config.json, um die Elmore-Verzögerung und den statischen IR-Spannungsabfall für das ausgewählte Netz und den ausgewählten Corner zu berechnen.

cat > "$PROJECT/inputs/synthetic.spef" <<'SPEF'
*SPEF "IEEE 1481 subset"
*DESIGN "synthetic"
*C_UNIT 1 FF
*R_UNIT 1 OHM
*NAME_MAP
*1 VDD
*2 VDD:src
*3 VDD:n1
*4 VDD:n2
*5 SIG:agg
*PORTS
*2 I
*D_NET *1 10.0
*CONN
*P *2 I
*I *3 B
*I *4 B
*CAP
1 *2 1.0
2 *3 2.0
3 *4 3.0
4 *4 *5 4.0
*RES
1 *2 *3 100.0
2 *3 *4 50.0
*END
SPEF

cat > "$PROJECT/inputs/spef-config.json" <<'JSON'
{"schema":"altifigence.px.spef-configured-analysis-config.v1","version":1,"spefArtifactId":"synthetic-spef","corner":{"model":"single_caller_resolved","name":"nominal"},"units":{"capacitance":"farad","resistance":"ohm","current":"ampere","time":"second","voltage":"volt"},"assumptions":{"couplingCapacitance":"reported_not_folded_into_elmore_load","elmoreTopology":"connected_resistor_tree","irDrop":"static_linear_resistor_network"},"elmore":{"net":"VDD","root":"VDD:src","target":"VDD:n2"},"irDrop":{"net":"VDD","ground":"VDD:src","currents":[{"node":"VDD:n2","currentA":0.001}]}}
JSON
alti px spef-summary --project "$PROJECT" synthetic.spef > "$WORK/spef-summary.json"
alti px spef-analyze --project "$PROJECT" synthetic.spef spef-config.json > "$WORK/spef-analysis.json"
jq -r .operationId "$WORK/spef-summary.json" "$WORK/spef-analysis.json"

altifigence.px.spef-summary.v1
altifigence.px.spef-configured-analysis.v1

Prüfen Sie bei invalid_job, ob das konfigurierte Netz, die Wurzel, das Ziel und die Stromquellenknoten mit den SPEF-Namen übereinstimmen. Verwenden Sie die oben gezeigten Einheiten und Annahmen und führen Sie die Analyse erneut aus.

Einen lokalen Job ausführen

Um die Timing-Anfrage als lokalen Job mit festen Grenzen auszuführen, berechnen Sie ihren SHA-256-Wert und übergeben Sie das Job-Dokument über stdin. Prüfen Sie, dass der Exit-Status 0 und der Ergebnisstatus succeeded ist. Bewahren Sie die zurückgegebene Artifact-URI für den gespeicherten Bericht auf.

DIGEST="$(sha256sum "$PROJECT/inputs/timing.json" | cut -d ' ' -f 1)"
cat > "$WORK/timing-job.template.json" <<'JSON'
{"schema":"altifigence.engine.job.v1","job_id":"timing-job-1","operation":{"engine_id":"px","operation_id":"static-timing","contract_id":"px.static-timing.v1"},"execution_placement":"local","device_preference":{"selection":{"mode":"class","value":"cpu"},"fallback":"deny"},"resources":{"cpu_slots":1,"memory_bytes":268435456,"device_slots":0,"device_memory_bytes":0,"max_wall_time_ms":60000},"inputs":[{"artifact_id":"timing-request","role":"static_timing_request","artifact_schema":"altifigence.px.static-timing-request.v1","uri":"workspace://inputs/timing.json","sha256":"REPLACE_WITH_DIGEST"}],"cancellation":{"cancellation_id":"cancel-timing-job-1"}}
JSON
jq --arg digest "$DIGEST" '.inputs[0].sha256 = $digest' "$WORK/timing-job.template.json" > "$WORK/timing-job.json"
alti px execute --project "$PROJECT" < "$WORK/timing-job.json" > "$WORK/job-result.json"
jq '{schema, status}' "$WORK/job-result.json"

{"schema":"altifigence.engine.result.v1","status":"succeeded"}

Wenn das Ergebnis px.local_runner.workspace_input meldet, speichern Sie die Anfrage unter inputs/ und berechnen Sie ihren SHA-256-Wert erneut. Verwenden Sie bei px.local_runner.output_exists neue Werte für job_id und cancellation_id, erzeugen Sie den Job erneut und führen Sie ihn wieder aus.

Über den lokalen Kompatibilitätsbefehl abfragen

Der lokale Kompatibilitätsbefehl akzeptiert capabilities und execute nach --. Führen Sie zum Lesen der installierten Funktionen Folgendes aus:

alti px analyze --runner local --project "$PROJECT" -- capabilities

Wenn der Kompatibilitätsbefehl eine lokale Engine-Operation anfordert, setzen Sie capabilities oder execute hinter --.

Eine festgeschriebene Analyse lesen

Wenn ein Projekt bereits eine festgeschriebene Logiktopologie-Analyse enthält, setzen Sie RUN_ID auf deren Ausführungs-ID. Readback lädt den gespeicherten Analyse-Envelope und Bericht, überprüft Netzliste und Bericht und gibt die überprüfte Operation mit Herkunftsnachweis aus.

alti px readback --project "$PROJECT" "$RUN_ID" > "$WORK/readback.json"
jq -r .schema "$WORK/readback.json"

altifigence.px.committed-logic-topology-readback.v1

Prüfen Sie bei input_io das Projektverzeichnis und den ausgewählten festgeschriebenen Lauf unter analyze/. Korrigieren Sie das Projekt oder die Lauf-ID und lesen Sie den Lauf erneut.

CLI-Engine-Befehle