Eseguire static timing e FDTD2D su CPU con alti px

Interroga le operazioni PX, esegui lo static timing da un input del progetto, conserva e riapri il risultato ed esegui la fixture FDTD2D su CPU.

Utilizza Altifigence CLI 0.1.9 su Linux per eseguire operazioni PX sui file nella cartella inputs/ del tuo progetto. Inizia con le query delle capability, esegui lo static timing a clock singolo, conserva il risultato nell’archivio di artefatti del progetto ed esegui la fixture FDTD2D integrata con il backend CPU.

Interrogare le operazioni PX

Leggi i documenti delle capability PX installate. Questi comandi sono query: stampano un documento JSON e non eseguono alcun job. alti px fdtd2d readiness riporta la prontezza di FDTD2D installato senza acquisire una lease CPU.

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

Verifica che il codice di uscita sia 0 per ogni comando.

Eseguire lo static timing

Utilizza un percorso assoluto del progetto locale ed esegui i comandi con il tuo normale account utente. PX legge i file di input dalla cartella inputs/ del progetto. Passa il nome del file relativo a 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 richiesta assegna a ogni arco un ritardo minimo e massimo esplicito in nanosecondi, un nodo sorgente e un clock ideale con vincoli di setup e hold. Mantieni univoci gli ID dei nodi e degli archi e fai puntare ogni arco a nodi elencati. Una richiesta contiene fino a 65536 nodi e 131072 archi entro 4194304 byte.

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

Verifica che il codice di uscita sia 0. I campi selezionati sono:

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

Il risultato contiene un report altifigence.px.static-timing-report.v1 con authority non_signoff, i tempi di arrivo e gli slack di ogni nodo e i digest dell’artefatto, dell’input e della richiesta.

Conservare e riaprire i risultati

Salva il risultato dello static timing nell’archivio di artefatti PX del progetto, quindi elenca le voci salvate e riapri la voce tramite il suo 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"

Verifica che il codice di uscita sia 0 per ogni comando. Lo store scrive un manifest con lo schema altifigence.px.artifact-manifest.v1. Il suo entryId è un SHA-256 in minuscolo di 64 caratteri e la voce è conservata sotto .altifigence/artifacts/px nel progetto. alti px artifact show riconvalida il risultato salvato e lo stampa di nuovo con lo schema altifigence.px.operation-result.v1.

Eseguire la fixture FDTD2D su CPU

Salva la richiesta della fixture FDTD2D integrata sotto inputs/ ed eseguila con il 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"

Verifica che il codice di uscita sia 0. Lo schema della ricevuta è altifigence.px.fdtd2d-execute-receipt.v1. Mantieni la richiesta entro 4096 byte. L’esecuzione su CPU è deterministica: eseguendo di nuovo la stessa richiesta si ottiene la stessa ricevuta.

Riprendere dopo errori PX

In caso di errori del motore static-timing, leggi la riga di errore JSON su stderr. Contiene lo schema altifigence.localRunner.error.v1, una categoria e un messaggio.

Se stderr riporta questa riga, non è stato possibile leggere il file di input al percorso indicato sotto inputs/:

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

Salva il file in $PROJECT/inputs/ e passa il suo percorso relativo a inputs/, ad esempio timing.json.

Se stderr riporta questa riga, la richiesta non corrisponde al proprio schema:

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

Per l’analisi temporale statica, utilizza i campi, la versione 1, lo schema e le regole del grafo della richiesta temporale precedente, quindi esegui di nuovo il comando. Per FDTD2D, utilizza lo schema e fixtureId della richiesta della fixture.

Se il comando stampa questo errore per alti px fdtd2d execute, il percorso di input non è un semplice percorso sotto inputs/:

PX numerical input must be a file below workspace inputs/

Passa il percorso relativo a inputs/ con separatori / e senza segmenti vuoti, . o .., ad esempio fdtd2d.json.

Compilare una ricetta di processo

Salva una fase di ossidazione come inputs/recipe.json. Esegui process-recipe per convalidare la ricetta e compilare il piano nell’ordine di dichiarazione. Conserva il risultato dell’operazione con gli stessi comandi dell’archivio degli artefatti usati per l’analisi temporale.

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}

Per invalid_job, confronta il file con l’esempio: utilizza lo schema px-recipe-1, oxidation in minuscolo e i campi del wafer e della fase elencati. Correggi il file, quindi esegui di nuovo process-recipe.

Riepilogare e analizzare SPEF

Salva il contenuto SPEF seguente come inputs/synthetic.spef. Il riepilogo riporta i resistori e i condensatori estratti. Salva la configurazione come inputs/spef-config.json per calcolare il ritardo di Elmore e la caduta IR statica per la rete e il corner selezionati.

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

Per invalid_job, verifica che la rete, la radice, la destinazione e i nodi delle sorgenti di corrente configurati corrispondano ai nomi SPEF. Utilizza le unità e le ipotesi mostrate sopra, quindi ripeti l’analisi.

Eseguire un job locale

Per eseguire la richiesta temporale come job locale con limiti definiti, calcola il suo SHA-256 e invia il documento del job su stdin. Verifica che il codice di uscita sia 0 e lo stato del risultato sia succeeded. Conserva l’URI dell’artefatto restituito per il rapporto salvato.

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

Se il risultato riporta px.local_runner.workspace_input, salva la richiesta sotto inputs/ e ricalcola il suo SHA-256. Per px.local_runner.output_exists, utilizza nuovi valori di job_id e cancellation_id, rigenera il job, quindi eseguilo di nuovo.

Eseguire query con il comando locale di compatibilità

Il comando locale di compatibilità accetta capabilities ed execute dopo --. Per leggere le funzionalità installate, esegui:

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

Se il comando di compatibilità richiede un’operazione del motore locale, inserisci capabilities o execute dopo --.

Leggere un’analisi confermata

Per un progetto che contiene già un’analisi della topologia logica confermata, imposta RUN_ID sull’ID di esecuzione di tale analisi. La rilettura carica il relativo envelope di analisi e il rapporto salvati, verifica la netlist e il rapporto e stampa l’operazione verificata con la provenienza.

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

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

Per input_io, verifica la directory del progetto e l’esecuzione confermata selezionata sotto analyze/. Correggi il progetto o l’ID di esecuzione e ripeti la lettura.

Comandi dei motori CLI