Exécuter le timing statique et FDTD2D sur CPU avec alti px

Interrogez les opérations PX, exécutez le timing statique à partir d’une entrée du projet, conservez et rouvrez le résultat, puis exécutez la fixture FDTD2D sur CPU.

Utilisez Altifigence CLI 0.1.9 sous Linux pour exécuter des opérations PX sur les fichiers du dossier inputs/ de votre projet. Commencez par les interrogations de capacités, exécutez le timing statique à une seule horloge, conservez le résultat dans le magasin d’artefacts du projet et exécutez la fixture FDTD2D intégrée avec le backend CPU.

Interroger les opérations PX

Lisez les documents de capacités PX installés. Ces commandes sont des interrogations : elles affichent un document JSON et n’exécutent aucun job. alti px fdtd2d readiness indique la disponibilité de FDTD2D installé sans acquérir de réservation CPU.

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

Vérifiez que le code de sortie est 0 pour chaque commande.

Exécuter le timing statique

Utilisez un chemin absolu vers votre projet local et exécutez les commandes avec votre compte utilisateur habituel. PX lit les fichiers d’entrée dans le dossier inputs/ du projet. Transmettez le nom de fichier relatif à 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

La requête indique pour chaque arc un délai minimal et un délai maximal explicites en nanosecondes, un nœud source et une horloge idéale avec des contraintes de setup et de hold. Gardez des ID de nœuds et des ID d’arcs uniques, et faites pointer chaque arc vers des nœuds listés. Une requête contient jusqu’à 65536 nœuds et 131072 arcs dans 4194304 octets.

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

Vérifiez que le code de sortie est 0. Les champs sélectionnés sont :

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

Le résultat contient un rapport altifigence.px.static-timing-report.v1 avec authority non_signoff, les temps d’arrivée et les slacks de chaque nœud, ainsi que les empreintes de l’artefact, de l’entrée et de la requête.

Conserver et rouvrir les résultats

Enregistrez le résultat du timing statique dans le magasin d’artefacts PX du projet, puis listez les entrées enregistrées et rouvrez l’entrée à partir de son ID.

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"

Vérifiez que le code de sortie est 0 pour chaque commande. L’enregistrement écrit un manifeste avec le schéma altifigence.px.artifact-manifest.v1. Son entryId est un SHA-256 de 64 caractères en minuscules, et l’entrée est conservée sous .altifigence/artifacts/px dans le projet. alti px artifact show revalide le résultat enregistré et l’affiche de nouveau avec le schéma altifigence.px.operation-result.v1.

Exécuter la fixture FDTD2D sur CPU

Enregistrez la requête de la fixture FDTD2D intégrée sous le dossier inputs/ et exécutez-la avec le backend CPU.

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"

Vérifiez que le code de sortie est 0. Le schéma du reçu est altifigence.px.fdtd2d-execute-receipt.v1. Limitez la requête à 4096 octets. L’exécution sur CPU est déterministe : relancer la même requête affiche le même reçu.

Reprendre après des erreurs PX

En cas d’échec du moteur static-timing, lisez la ligne d’erreur JSON sur stderr. Elle contient le schéma altifigence.localRunner.error.v1, une catégorie et un message.

Si stderr signale cette ligne, le fichier d’entrée n’a pas pu être lu au chemin indiqué sous inputs/ :

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

Enregistrez le fichier dans $PROJECT/inputs/ et transmettez son chemin relatif à inputs/, par exemple timing.json.

Si stderr signale cette ligne, la requête ne correspond pas à son schéma :

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

Pour l’analyse temporelle statique, utilisez les champs, la version 1, le schéma et les règles du graphe de la requête temporelle ci-dessus, puis relancez la commande. Pour FDTD2D, utilisez le schéma et fixtureId de la requête de la fixture.

Si la commande affiche cette erreur pour alti px fdtd2d execute, le chemin d’entrée n’est pas un chemin simple sous inputs/ :

PX numerical input must be a file below workspace inputs/

Transmettez le chemin relatif à inputs/ avec des séparateurs / et sans segment vide, . ou .., par exemple fdtd2d.json.

Compiler une recette de procédé

Enregistrez une étape d’oxydation dans inputs/recipe.json. Exécutez process-recipe pour valider la recette et compiler son plan dans l’ordre de déclaration. Conservez le résultat de l’opération avec les mêmes commandes du magasin d’artefacts que pour l’analyse temporelle.

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}

Pour invalid_job, comparez le fichier à l’exemple : utilisez le schéma px-recipe-1, oxidation en minuscules et les champs de plaquette et d’étape indiqués. Corrigez le fichier, puis relancez process-recipe.

Résumer et analyser un fichier SPEF

Enregistrez le contenu SPEF ci-dessous dans inputs/synthetic.spef. Le résumé présente les résistances et les condensateurs extraits. Enregistrez la configuration dans inputs/spef-config.json pour calculer le délai d’Elmore et la chute IR statique pour le réseau et le coin sélectionnés.

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

Pour invalid_job, vérifiez que le réseau, la racine, la cible et les nœuds des sources de courant configurés correspondent aux noms SPEF. Utilisez les unités et les hypothèses indiquées ci-dessus, puis relancez l’analyse.

Exécuter une tâche locale

Pour exécuter la requête temporelle comme une tâche locale à limites définies, calculez son SHA-256 et transmettez le document de tâche sur stdin. Vérifiez que le code de sortie est 0 et que l’état du résultat est succeeded. Conservez l’URI d’artefact renvoyée pour le rapport enregistré.

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

Si le résultat indique px.local_runner.workspace_input, enregistrez la requête sous inputs/ et recalculez son SHA-256. Pour px.local_runner.output_exists, utilisez de nouvelles valeurs pour job_id et cancellation_id, régénérez la tâche, puis exécutez-la à nouveau.

Interroger avec la commande locale de compatibilité

La commande locale de compatibilité accepte capabilities et execute après --. Pour lire les capacités installées, exécutez :

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

Si la commande de compatibilité demande une opération de moteur local, placez capabilities ou execute après --.

Lire une analyse validée et enregistrée

Pour un projet contenant déjà une analyse de topologie logique validée et enregistrée, définissez RUN_ID sur l’identifiant d’exécution de cette analyse. La relecture charge son enveloppe d’analyse et son rapport enregistrés, vérifie la netlist et le rapport, puis affiche l’opération vérifiée avec sa provenance.

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

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

Pour input_io, vérifiez le répertoire du projet et l’exécution validée sélectionnée sous analyze/. Corrigez le projet ou l’identifiant d’exécution, puis relisez cette dernière.

Commandes CLI des moteurs