alti px से CPU पर स्टैटिक टाइमिंग और FDTD2D चलाएँ

Linux पर Altifigence CLI 0.1.9 से अपने प्रोजेक्ट के inputs/ फ़ोल्डर की फ़ाइलों पर PX ऑपरेशन चलाएँ। क्षमता की क्वेरी से शुरू करें, सिंगल-क्लॉक स्टैटिक टाइमिंग चलाएँ, परिणाम को प्रोजेक्ट के आर्टिफ़ैक्ट स्टोर में सहेजें और CPU बैकएंड के साथ अंतर्निर्मित FDTD2D फ़िक्स्चर चलाएँ।

PX ऑपरेशन की क्वेरी करें

इंस्टॉल किए गए PX क्षमता दस्तावेज़ पढ़ें। ये कमांड क्वेरी हैं: ये JSON दस्तावेज़ प्रिंट करते हैं और कोई जॉब नहीं चलाते। alti px fdtd2d readiness बिना CPU लीज़ लिए इंस्टॉल किए गए FDTD2D की तैयारी की स्थिति बताता है।

alti px capabilities
alti px fdtd2d capabilities
alti px fdtd2d readiness

सुनिश्चित करें कि हर कमांड का एग्ज़िट स्टेटस 0 हो।

स्टैटिक टाइमिंग चलाएँ

अपने लोकल प्रोजेक्ट का पूर्ण पाथ इस्तेमाल करें और कमांड अपने सामान्य उपयोगकर्ता खाते से चलाएँ। PX इनपुट फ़ाइलें प्रोजेक्ट के inputs/ फ़ोल्डर से पढ़ता है। फ़ाइल का नाम 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

अनुरोध में हर आर्क के लिए नैनोसेकंड में स्पष्ट न्यूनतम और अधिकतम विलंब, एक स्रोत नोड और सेटअप तथा होल्ड बाधाओं वाली एक आदर्श क्लॉक दी जाती है। नोड ID और आर्क ID अद्वितीय रखें और हर आर्क को सूचीबद्ध नोड की ओर इंगित करें। एक अनुरोध में 4194304 बाइट के भीतर अधिकतम 65536 नोड और 131072 आर्क हो सकते हैं।

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

सुनिश्चित करें कि एग्ज़िट स्टेटस 0 हो। चुने हुए फ़ील्ड ये हैं:

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

परिणाम में altifigence.px.static-timing-report.v1 रिपोर्ट होती है, जिसमें authority non_signoff है, हर नोड के आगमन समय और स्लैक हैं, तथा आर्टिफ़ैक्ट, इनपुट और अनुरोध के डाइजेस्ट हैं।

परिणाम सहेजें और फिर खोलें

स्टैटिक-टाइमिंग परिणाम को प्रोजेक्ट के PX आर्टिफ़ैक्ट स्टोर में रखें, फिर सहेजी गई प्रविष्टियों की सूची देखें और प्रविष्टि को उसकी 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"

सुनिश्चित करें कि हर कमांड का एग्ज़िट स्टेटस 0 हो। स्टोर स्कीमा altifigence.px.artifact-manifest.v1 वाला मैनिफ़ेस्ट लिखता है। उसका entryId 64 अक्षरों का लोअरकेस SHA-256 है और प्रविष्टि प्रोजेक्ट में .altifigence/artifacts/px के नीचे रखी जाती है। alti px artifact show सहेजे गए परिणाम को फिर से सत्यापित करता है और उसे स्कीमा altifigence.px.operation-result.v1 के साथ दोबारा प्रिंट करता है।

CPU पर FDTD2D फ़िक्स्चर चलाएँ

अंतर्निर्मित FDTD2D फ़िक्स्चर अनुरोध को inputs/ के नीचे सहेजें और 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"

सुनिश्चित करें कि एग्ज़िट स्टेटस 0 हो। रसीद का स्कीमा altifigence.px.fdtd2d-execute-receipt.v1 है। अनुरोध को 4096 बाइट के भीतर रखें। CPU रन नियतात्मक है: वही अनुरोध दोबारा चलाने पर वही रसीद प्रिंट होती है।

PX त्रुटियों के बाद सुधार करें

static-timing इंजन विफल होने पर stderr में JSON त्रुटि पंक्ति पढ़ें। उसका स्कीमा altifigence.localRunner.error.v1 है और उसमें एक श्रेणी तथा एक संदेश होता है।

अगर stderr में यह पंक्ति दिखे, तो इनपुट फ़ाइल inputs/ के नीचे दिए गए पाथ पर पढ़ी नहीं जा सकी:

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

फ़ाइल को $PROJECT/inputs/ में सहेजें और उसका पाथ inputs/ के सापेक्ष दें, उदाहरण के लिए timing.json।

अगर stderr में यह पंक्ति दिखे, तो अनुरोध अपने स्कीमा से मेल नहीं खाता:

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

स्टैटिक टाइमिंग के लिए ऊपर दिए टाइमिंग अनुरोध के फ़ील्ड, वर्शन 1, स्कीमा और ग्राफ़ नियम इस्तेमाल करें, फिर कमांड दोबारा चलाएँ। FDTD2D के लिए फ़िक्स्चर अनुरोध का स्कीमा और fixtureId इस्तेमाल करें।

अगर alti px fdtd2d execute के लिए कमांड यह त्रुटि प्रिंट करे, तो इनपुट पाथ inputs/ के नीचे का सादा पाथ नहीं है:

PX numerical input must be a file below workspace inputs/

पाथ inputs/ के सापेक्ष दें, जिसमें विभाजक / हों और कोई खाली, . या .. खंड न हो, उदाहरण के लिए fdtd2d.json।

प्रोसेस रेसिपी कंपाइल करें

एक ऑक्सिडेशन चरण को inputs/recipe.json के रूप में सहेजें। रेसिपी सत्यापित करने और घोषणा क्रम में उसकी योजना कंपाइल करने के लिए process-recipe चलाएँ। टाइमिंग के लिए इस्तेमाल किए गए उन्हीं आर्टिफ़ैक्ट स्टोर कमांड से उसका ऑपरेशन परिणाम सहेजें।

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}

invalid_job आने पर फ़ाइल की तुलना उदाहरण से करें: स्कीमा px-recipe-1, लोअरकेस oxidation और सूचीबद्ध वेफ़र तथा चरण फ़ील्ड इस्तेमाल करें। फ़ाइल ठीक करें, फिर process-recipe दोबारा चलाएँ।

SPEF का सारांश और विश्लेषण करें

नीचे दिए SPEF को inputs/synthetic.spef के रूप में सहेजें। सारांश निकाले गए रेज़िस्टर और कैपेसिटर बताता है। चुने गए नेट और कॉर्नर के लिए Elmore विलंब और स्टैटिक IR ड्रॉप की गणना करने हेतु कॉन्फ़िगरेशन को inputs/spef-config.json के रूप में सहेजें।

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

invalid_job आने पर जाँचें कि कॉन्फ़िगर किए गए नेट, रूट, लक्ष्य और करंट-सोर्स नोड SPEF के नामों से मेल खाते हों। ऊपर दिखाई गई इकाइयाँ और मान्यताएँ इस्तेमाल करें, फिर विश्लेषण दोबारा चलाएँ।

लोकल जॉब चलाएँ

टाइमिंग अनुरोध को सीमाबद्ध लोकल जॉब के रूप में चलाने के लिए उसके SHA-256 की गणना करें और जॉब दस्तावेज़ stdin पर भेजें। सुनिश्चित करें कि एग्ज़िट स्टेटस 0 और परिणाम स्टेटस succeeded हो। सहेजी गई रिपोर्ट के लिए लौटाया गया आर्टिफ़ैक्ट URI सुरक्षित रखें।

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

अगर परिणाम px.local_runner.workspace_input बताए, तो अनुरोध को inputs/ के नीचे सहेजें और उसके SHA-256 की फिर गणना करें। px.local_runner.output_exists आने पर नए job_id और cancellation_id इस्तेमाल करें, जॉब फिर बनाएँ और दोबारा चलाएँ।

लोकल संगतता कमांड से क्वेरी करें

लोकल संगतता कमांड -- के बाद capabilities और execute स्वीकार करता है। इंस्टॉल की गई क्षमताएँ पढ़ने के लिए चलाएँ:

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

अगर संगतता कमांड किसी लोकल इंजन ऑपरेशन की माँग करे, तो -- के बाद capabilities या execute रखें।

कमिट किया गया विश्लेषण पढ़ें

जिस प्रोजेक्ट में कमिट किया गया लॉजिक-टोपोलॉजी विश्लेषण पहले से हो, उसके लिए RUN_ID को उस विश्लेषण के रन ID पर सेट करें। Readback उसके सहेजे गए विश्लेषण एन्वलप और रिपोर्ट लोड करता है, नेटलिस्ट और रिपोर्ट सत्यापित करता है और प्रोवेनेंस के साथ सत्यापित ऑपरेशन प्रिंट करता है।

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

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

input_io आने पर प्रोजेक्ट डायरेक्टरी और analyze/ के नीचे चुना गया कमिट किया गया रन जाँचें। प्रोजेक्ट या रन ID ठीक करें और उसे फिर पढ़ें।

CLI इंजन कमांड