Ejecutar temporización estática y FDTD2D en CPU con alti px

Consulte las operaciones de PX, ejecute la temporización estática a partir de una entrada del proyecto, conserve y vuelva a abrir el resultado, y ejecute el fixture FDTD2D en CPU.

Utilice Altifigence CLI 0.1.9 en Linux para ejecutar operaciones de PX sobre archivos de la carpeta inputs/ de su proyecto. Empiece con las consultas de capacidades, ejecute la temporización estática de un solo reloj, conserve el resultado en el almacén de artefactos del proyecto y ejecute el fixture FDTD2D integrado con el backend CPU.

Consultar operaciones de PX

Lea los documentos de capacidades de PX instalados. Estos comandos son consultas: imprimen un documento JSON y no ejecutan ningún trabajo. alti px fdtd2d readiness informa del estado de preparación de FDTD2D instalado sin tomar una reserva (lease) de CPU.

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

Compruebe que el estado de salida de cada comando sea 0.

Ejecutar la temporización estática

Utilice una ruta absoluta a su proyecto local y ejecute los comandos con su usuario habitual. PX lee los archivos de entrada de la carpeta inputs/ del proyecto. Pase el nombre del archivo 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 solicitud asigna a cada arco un retardo mínimo y máximo explícito en nanosegundos, un nodo de origen y un reloj ideal con restricciones de setup y de hold. Mantenga únicos los ID de nodo y de arco, y haga que cada arco apunte a nodos de la lista. Una solicitud puede contener hasta 65536 nodos y 131072 arcos, dentro de 4194304 bytes.

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

Compruebe que el estado de salida sea 0. Los campos seleccionados son:

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

El resultado incluye un informe altifigence.px.static-timing-report.v1 con authority non_signoff, los tiempos de llegada y las holguras de cada nodo, y los resúmenes del artefacto, de la entrada y de la solicitud.

Conservar y volver a abrir resultados

Almacene el resultado de la temporización estática en el almacén de artefactos PX del proyecto y, después, enumere las entradas almacenadas y vuelva a abrir la entrada por su 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"

Compruebe que el estado de salida de cada comando sea 0. El almacén escribe un manifiesto con el esquema altifigence.px.artifact-manifest.v1. Su entryId es un SHA-256 de 64 caracteres en minúsculas, y la entrada se conserva bajo .altifigence/artifacts/px en el proyecto. alti px artifact show vuelve a validar el resultado almacenado y lo imprime de nuevo con el esquema altifigence.px.operation-result.v1.

Ejecutar el fixture FDTD2D en CPU

Guarde en inputs/ la solicitud del fixture FDTD2D integrado y ejecútela con el 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"

Compruebe que el estado de salida sea 0. El esquema del comprobante es altifigence.px.fdtd2d-execute-receipt.v1. Mantenga la solicitud dentro de 4096 bytes. La ejecución en CPU es determinista: si vuelve a ejecutar la misma solicitud, se imprime el mismo comprobante.

Resolver errores de PX

Si falla el motor static-timing, lea la línea de error JSON en stderr. Contiene el esquema altifigence.localRunner.error.v1, una categoría y un mensaje.

Si stderr informa de esta línea, no se pudo leer el archivo de entrada en la ruta indicada dentro de inputs/:

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

Guarde el archivo en $PROJECT/inputs/ y pase su ruta relativa a inputs/, por ejemplo timing.json.

Si stderr informa de esta línea, la solicitud no coincide con su esquema:

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

Para el análisis temporal estático, utilice los campos, la versión 1, el esquema y las reglas del grafo de la solicitud temporal anterior y vuelva a ejecutar el comando. Para FDTD2D, utilice el esquema y fixtureId de la solicitud del caso de prueba.

Si el comando imprime este error para alti px fdtd2d execute, la ruta de entrada no es una ruta simple dentro de inputs/:

PX numerical input must be a file below workspace inputs/

Pase la ruta relativa a inputs/ con separadores / y sin segmentos vacíos, . ni .., por ejemplo fdtd2d.json.

Compilar una receta de proceso

Guarde un paso de oxidación como inputs/recipe.json. Ejecute process-recipe para validar la receta y compilar su plan en el orden de declaración. Conserve el resultado de la operación con los mismos comandos del almacén de artefactos que se utilizan para el análisis temporal.

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}

Para invalid_job, compare el archivo con el ejemplo: utilice el esquema px-recipe-1, oxidation en minúsculas y los campos de oblea y paso indicados. Corrija el archivo y vuelva a ejecutar process-recipe.

Resumir y analizar SPEF

Guarde el contenido SPEF siguiente como inputs/synthetic.spef. El resumen presenta las resistencias y los condensadores extraídos. Guarde la configuración como inputs/spef-config.json para calcular el retardo de Elmore y la caída IR estática de la red y la esquina seleccionadas.

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

Para invalid_job, compruebe que la red, la raíz, el destino y los nodos de las fuentes de corriente configurados coincidan con los nombres SPEF. Utilice las unidades y suposiciones indicadas y vuelva a ejecutar el análisis.

Ejecutar un trabajo local

Para ejecutar la solicitud temporal como un trabajo local con límites definidos, calcule su SHA-256 y envíe el documento del trabajo por stdin. Compruebe que el estado de salida sea 0 y el estado del resultado sea succeeded. Conserve el URI del artefacto devuelto para el informe guardado.

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 el resultado indica px.local_runner.workspace_input, guarde la solicitud bajo inputs/ y vuelva a calcular su SHA-256. Para px.local_runner.output_exists, utilice nuevos valores de job_id y cancellation_id, regenere el trabajo y vuelva a ejecutarlo.

Consultar mediante el comando local de compatibilidad

El comando local de compatibilidad acepta capabilities y execute después de --. Para leer las capacidades instaladas, ejecute:

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

Si el comando de compatibilidad solicita una operación del motor local, coloque capabilities o execute después de --.

Leer un análisis confirmado

Si un proyecto ya contiene un análisis de topología lógica confirmado, asigne a RUN_ID el identificador de ejecución de ese análisis. La lectura carga su sobre de análisis y su informe guardados, verifica la netlist y el informe, y muestra la operación verificada con su procedencia.

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

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

Para input_io, compruebe el directorio del proyecto y la ejecución confirmada seleccionada bajo analyze/. Corrija el proyecto o el identificador de ejecución y vuelva a leerla.

Comandos de motor de la CLI