Executar temporização estática e FDTD2D na CPU com alti px

Consulte as operações do PX, execute a temporização estática a partir de uma entrada do projeto, guarde e reabra o resultado e execute o fixture FDTD2D na CPU.

Use o Altifigence CLI 0.1.9 no Linux para executar operações do PX em arquivos da pasta inputs/ do seu projeto. Comece com as consultas de capacidades, execute a temporização estática de um único clock, guarde o resultado no armazenamento de artefatos do projeto e execute o fixture FDTD2D integrado com o backend de CPU.

Consultar operações do PX

Leia os documentos de capacidades do PX instalados. Estes comandos são consultas: eles imprimem um documento JSON e não executam nenhuma tarefa. alti px fdtd2d readiness informa a prontidão do FDTD2D instalado sem obter uma reserva (lease) de CPU.

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

Exija o status de saída 0 em cada comando.

Executar a temporização estática

Use um caminho absoluto para seu projeto local e execute os comandos com sua conta de usuário comum. O PX lê os arquivos de entrada da pasta inputs/ do projeto. Passe o nome do arquivo 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

A solicitação atribui a cada arco um atraso mínimo e máximo explícito em nanossegundos, um nó de origem e um clock ideal com restrições de setup e hold. Mantenha os IDs de nó e de arco únicos e faça cada arco apontar para nós listados. Uma solicitação pode conter até 65536 nós e 131072 arcos, dentro de 4194304 bytes.

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

Exija o status de saída 0. Os campos selecionados são:

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

O resultado traz um relatório altifigence.px.static-timing-report.v1 com authority non_signoff, os tempos de chegada e as folgas de cada nó, e os resumos do artefato, da entrada e da solicitação.

Guardar e reabrir resultados

Armazene o resultado da temporização estática no armazenamento de artefatos PX do projeto e, depois, liste as entradas armazenadas e reabra a entrada pelo 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"

Exija o status de saída 0 em cada comando. O armazenamento grava um manifesto com o esquema altifigence.px.artifact-manifest.v1. Seu entryId é um SHA-256 de 64 caracteres em minúsculas, e a entrada fica guardada em .altifigence/artifacts/px no projeto. alti px artifact show valida novamente o resultado armazenado e o imprime outra vez com o esquema altifigence.px.operation-result.v1.

Executar o fixture FDTD2D na CPU

Salve em inputs/ a solicitação do fixture FDTD2D integrado e execute-a com o backend de 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"

Exija o status de saída 0. O esquema do comprovante é altifigence.px.fdtd2d-execute-receipt.v1. Mantenha a solicitação em até 4096 bytes. A execução na CPU é determinística: executar a mesma solicitação novamente imprime o mesmo comprovante.

Resolver erros do PX

Em caso de falha do mecanismo static-timing, leia a linha de erro JSON em stderr. Ela contém o esquema altifigence.localRunner.error.v1, uma categoria e uma mensagem.

Se stderr informar esta linha, não foi possível ler o arquivo de entrada no caminho indicado dentro de inputs/:

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

Salve o arquivo em $PROJECT/inputs/ e passe o caminho relativo a inputs/, por exemplo timing.json.

Se stderr informar esta linha, a solicitação não corresponde ao seu esquema:

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

Para a análise estática de temporização, use os campos, a versão 1, o esquema e as regras do grafo da solicitação de temporização acima e execute o comando novamente. Para FDTD2D, use o esquema e fixtureId da solicitação do caso de teste.

Se o comando imprimir este erro para alti px fdtd2d execute, o caminho de entrada não é um caminho simples dentro de inputs/:

PX numerical input must be a file below workspace inputs/

Passe o caminho relativo a inputs/ com separadores / e sem segmentos vazios, . ou .., por exemplo fdtd2d.json.

Compilar uma receita de processo

Salve uma etapa de oxidação como inputs/recipe.json. Execute process-recipe para validar a receita e compilar seu plano na ordem de declaração. Guarde o resultado da operação com os mesmos comandos do armazenamento de artefatos usados para a temporização.

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 o arquivo com o exemplo: use o esquema px-recipe-1, oxidation em minúsculas e os campos de wafer e etapa listados. Corrija o arquivo e execute process-recipe novamente.

Resumir e analisar SPEF

Salve o conteúdo SPEF abaixo como inputs/synthetic.spef. O resumo apresenta os resistores e capacitores extraídos. Salve a configuração como inputs/spef-config.json para calcular o atraso de Elmore e a queda IR estática para a rede e o corner selecionados.

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, confira se a rede, a raiz, o destino e os nós das fontes de corrente configurados correspondem aos nomes SPEF. Use as unidades e premissas mostradas acima e execute a análise novamente.

Executar um job local

Para executar a solicitação de temporização como um job local com limites definidos, calcule seu SHA-256 e envie o documento do job por stdin. Exija o status de saída 0 e o status de resultado succeeded. Guarde o URI do artefato retornado para o relatório salvo.

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 o resultado informar px.local_runner.workspace_input, salve a solicitação em inputs/ e recalcule seu SHA-256. Para px.local_runner.output_exists, use novos valores de job_id e cancellation_id, gere o job novamente e execute-o outra vez.

Consultar pelo comando local de compatibilidade

O comando local de compatibilidade aceita capabilities e execute após --. Para ler as capacidades instaladas, execute:

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

Se o comando de compatibilidade solicitar uma operação do mecanismo local, coloque capabilities ou execute após --.

Ler uma análise confirmada

Para um projeto que já contém uma análise de topologia lógica confirmada, defina RUN_ID como o ID de execução dessa análise. A releitura carrega seu envelope de análise e relatório salvos, verifica a netlist e o relatório e imprime a operação verificada com a procedência.

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, confira o diretório do projeto e a execução confirmada selecionada em analyze/. Corrija o projeto ou o ID de execução e faça a leitura novamente.

Comandos de engine da CLI