सहेजे गए RTL का सिमुलेशन करें और परिणाम सहेजें

Linux पर Altifigence CLI 0.1.9 से बंडल किए गए RTL इंजन द्वारा सहेजे गए SystemVerilog का सिमुलेशन करें। admit, preflight और run सिमुलेशन कमांड में से हर एक आपके प्रोजेक्ट के भीतर एक अनुरोध फ़ाइल पढ़ता है और JSON प्रिंट करता है। चार-स्टेट मल्टी-क्लॉक सिमुलेशन कॉन्ट्रैक्ट पढ़ने के लिए alti rtl simulate-v2 capabilities चलाएँ।

सिमुलेशन अनुरोध सहेजें

प्रोजेक्ट फ़ोल्डर बनाएँ और इस अनुरोध को उसमें sim.json के रूप में सहेजें। ठीक यही चार टॉप-लेवल कीज़ इस्तेमाल करें। अनुरोध में SystemVerilog सोर्स, क्लॉक पोर्ट और अवधि, वैकल्पिक रीसेट, रजिस्टरों के प्रारंभिक मान और हर साइकल के लिए एक इनपुट वेक्टर होता है।

mkdir -p "$HOME/alti-projects/demo-project"
PROJECT="$(cd "$HOME/alti-projects/demo-project" && pwd -P)"

{
  "schema": "altifigence.rtl.operation-request.v1",
  "version": 1,
  "operationId": "altifigence.rtl.simulate.v1",
  "request": {
    "top": "top",
    "sources": [
      {
        "path": "workspace/top.sv",
        "source": "module top(\n  input logic clk,\n  input logic rst,\n  input logic d,\n  output logic q\n);\n  always_ff @(posedge clk or posedge rst)\n    if (rst) q <= 1'b0;\n    else q <= d;\nendmodule\n"
      }
    ],
    "clock": {
      "port": "clk",
      "periodPs": 1000
    },
    "initialRegisterValues": [
      false
    ],
    "cycles": [
      {
        "inputs": {
          "d": [
            false
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            true
          ]
        }
      },
      {
        "inputs": {
          "d": [
            false
          ]
        }
      }
    ],
    "limits": {
      "maxCycles": 4,
      "maxTimePs": 4000
    },
    "reset": {
      "port": "rst",
      "activeLevel": "active_high",
      "assertCycles": 1
    }
  }
}

क्लॉक और रीसेट को छोड़कर हर टॉप-लेवल इनपुट को हर साइकल में दें, सबसे कम महत्व वाला बिट पहले। इंजन क्लॉक चलाता है और पहले assertCycles साइकल के लिए रीसेट असर्ट करता है। clock.periodPs को 2 से 1000000000 के बीच रखें। limits.maxCycles को साइकल की संख्या से लेकर 32768 तक और limits.maxTimePs को साइकल × periodPs से लेकर 1000000000000 तक सेट करें। अनुरोध फ़ाइल अधिकतम 272629760 बाइट की हो सकती है।

चलाने से पहले अनुरोध जाँचें

alti rtl simulate admit --project "$PROJECT" sim.json
alti rtl simulate preflight --project "$PROJECT" sim.json > "$PROJECT/preflight.json"
jq -c '[.outputPorts[].name]' "$PROJECT/preflight.json"

सुनिश्चित करें कि हर कमांड का एग्ज़िट स्टेटस 0 हो। Admit अनुरोध का ढाँचा और सीमाएँ जाँचता है और altifigence.rtl.simulation-admission.v1 लौटाता है, जिसमें admitted true होता है; इस अनुरोध के लिए वह cycleCount 4, transitionStepCount 8 और simulatedTimePs 4000 बताता है। Preflight सोर्स को लॉजिक नेटलिस्ट में सिंथेसाइज़ भी करता है और इनपुट पोर्ट, आउटपुट पोर्ट और रजिस्टरों के साथ altifigence.rtl.simulation-preflight.v1 लौटाता है। jq वाली पंक्ति यह प्रिंट करती है:

["q"]

Admit और preflight पूर्व-जाँच हैं। सिमुलेशन केवल run से चलता है।

सिमुलेशन चलाएँ

alti rtl simulate run --project "$PROJECT" sim.json > "$PROJECT/result.json"
jq -c '.artifact.payload.summaryArtifact.payload.finalOutputsLsb0' "$PROJECT/result.json"
jq -r '.artifact.payload.waveformArtifact.payload' "$PROJECT/result.json" > "$PROJECT/wave.vcd"

सुनिश्चित करें कि एग्ज़िट स्टेटस 0 हो। परिणाम का स्कीमा altifigence.rtl.operation-result.v1 और operationId altifigence.rtl.simulate.v1 है। उसका आर्टिफ़ैक्ट altifigence.rtl.simulation-receipt.v1 रसीद है, जिसमें preflight, इवेंट-स्टेप ट्रेस, VCD वेवफ़ॉर्म, सारांश और प्रोवेनेंस हैं। इस अनुरोध के लिए अंतिम आउटपुट यह है:

{"q":[false]}

बंडल किया गया इंजन डिज़ाइन को सिंथेसाइज़ करता है और अपने दो-स्टेट इवेंट-स्टेप सिमुलेटर से उसे चलाता है। wave.vcd में 1ps टाइमस्केल है।

सोर्स फ़ाइल का निरीक्षण करें और उसे सिंथेसाइज़ करें

उसी मॉड्यूल को प्रोजेक्ट फ़ाइल के रूप में सहेजें, फिर उसका स्कीमैटिक निकालें और उसे सिंथेसाइज़ करें। सोर्स फ़ाइलों के पाथ प्रोजेक्ट के सापेक्ष होते हैं।

mkdir -p "$PROJECT/rtl"
jq -r '.request.sources[0].source' "$PROJECT/sim.json" > "$PROJECT/rtl/top.sv"
alti rtl schematic --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/schematic.json"
jq -c '{schema, source}' "$PROJECT/schematic.json"

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

{"schema":"alti-rtl-schematic.v1","source":"saved-files"}

दस्तावेज़ में topModule, modules, instances, nets, connections, diagnostics और unsupported भी होते हैं। उसका status complete या partial होता है; failed दस्तावेज़ एग्ज़िट स्टेटस 1 के साथ समाप्त होता है।

alti rtl synth --project "$PROJECT" --top top rtl/top.sv > "$PROJECT/synth.json"
jq -c '{report: .report.schema, netlist: .netlist.schema, cells: .report.stats.cells_by_kind}' "$PROJECT/synth.json"

सुनिश्चित करें कि एग्ज़िट स्टेटस 0 हो। Synth लॉजिक नेटलिस्ट और उसकी सिंथेसिस रिपोर्ट प्रिंट करता है। इस मॉड्यूल के लिए jq वाली पंक्ति यह प्रिंट करती है:

{"report":"rtl-synth-report-2","netlist":"logic-netlist-2","cells":{"dff_posedge_async_reset":1}}

अगर synth alti-rtl: synth requires at least one SystemVerilog file के साथ रुक जाए, तो विकल्पों के बाद सोर्स फ़ाइल का पाथ जोड़ें, जैसे rtl/top.sv।

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

alti rtl artifact store --project "$PROJECT" result.json > "$PROJECT/manifest.json"
ENTRY_ID="$(jq -r '.entryId' "$PROJECT/manifest.json")"
alti rtl artifact list --project "$PROJECT"
alti rtl artifact show --project "$PROJECT" "$ENTRY_ID" > "$PROJECT/reopened.json"

Store पूरे परिणाम को मान्य करता है और उसे प्रोजेक्ट में .altifigence/artifacts/rtl/ के नीचे लिखता है। उसके altifigence.rtl.artifact-manifest.v1 मैनिफ़ेस्ट में entryId (सहेजे गए परिणाम का SHA-256) और relativePath results/<entryId>.json होते हैं। List हर मैनिफ़ेस्ट प्रिंट करता है; show सहेजा गया परिणाम JSON प्रिंट करता है। परिणाम अधिकतम 67108864 बाइट का हो सकता है।

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

RTL simulation request must be the exact altifigence.rtl.simulate.v1 envelope आने पर फ़ाइल में ठीक schema, version, operationId और request कीज़ दें, वही मान रखते हुए जो ऊपर दिखाए गए हैं।

RTL simulation request must be a normalized project-relative path आने पर पाथ प्रोजेक्ट के सापेक्ष दें, जैसे sim.json, और शुरुआत में ./ या / न लगाएँ।

इंजन अनुरोध त्रुटियाँ alti-rtl: के बाद प्रिंट करता है और स्टेटस 2 के साथ समाप्त होता है। RTL simulation resource limit exceeded for stimulus cycles: observed 5, maximum 4 आने पर limits.maxCycles को साइकल की संख्या तक बढ़ाएँ और admit फिर चलाएँ।

RTL simulation resource limit exceeded for simulated time ps: observed 5000, maximum 4000 आने पर limits.maxTimePs को कम से कम साइकल की संख्या × clock.periodPs तक बढ़ाएँ।

RTL artifact entry does not exist: के बाद कोई id आने पर alti rtl artifact list से कोई entryId कॉपी करें और show फिर चलाएँ।

सहेजी गई सोर्स फ़ाइलें जाँचें और उनका विश्लेषण करें

पिछले खंड की सहेजी गई rtl/top.sv इस्तेमाल करें। उसके डायग्नोस्टिक जाँचें, चेकर कवरेज और हायरार्की का निरीक्षण करें, फिर नेटिव सिंबल विश्लेषण पढ़ें। निष्पादन विकल्प कंपाइलर सबकमांड के बाद रखें।

alti rtl compile check --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile coverage --runner local --project "$PROJECT" -- rtl/top.sv --format json
alti rtl compile hierarchy --runner local --project "$PROJECT" -- rtl/top.sv --top top --format json
alti rtl analysis --project "$PROJECT" rtl/top.sv > "$PROJECT/analysis.json"
jq -c '{schemaVersion}' "$PROJECT/analysis.json"

{"schemaVersion":"sv-symbols.v2"}

संगतता के लिए प्रयुक्त नाम synthesize भी लोकल सिंथेसाइज़र चलाता है। उसके इंजन आर्ग्युमेंट -- के बाद दें:

alti rtl synthesize --runner local --project "$PROJECT" -- --top top rtl/top.sv > "$PROJECT/synth-compat.json"

RTL compiler execution options must follow the explicit subcommand आने पर ऊपर दिखाए अनुसार --runner local और --project को check, coverage या hierarchy के बाद रखें।

कॉम्बिनेशनल नेटलिस्ट को सेल से मैप करें

एक अलग कॉम्बिनेशनल उदाहरण और छोटी Liberty लाइब्रेरी सहेजें। उसकी नेटलिस्ट सिंथेसाइज़ करें, फिर हर लॉजिक सेल को समान फ़ंक्शन वाले लाइब्रेरी सेल से मैप करें।

cat > "$PROJECT/rtl/map-example.sv" <<'SV'
module top(input logic a, input logic b, output logic y);
  logic n;
  assign n = a & b;
  assign y = ~n;
endmodule
SV
cat > "$PROJECT/map-example.lib" <<'LIB'
library (neutral) {
  cell (AND2) {
    area : 2.0;
    pin (A) { direction : input; }
    pin (B) { direction : input; }
    pin (Y) { direction : output; function : "A & B"; }
  }
  cell (INV) {
    area : 1.0;
    pin (A) { direction : input; }
    pin (Y) { direction : output; function : "!A"; }
  }
}
LIB
alti rtl synth --project "$PROJECT" --top top --netlist-only rtl/map-example.sv > "$PROJECT/map-netlist.json"
alti rtl map --project "$PROJECT" --netlist map-netlist.json --liberty map-example.lib > "$PROJECT/map-report.json"
jq -c '{schema, mapped_cell_count, total_area}' "$PROJECT/map-report.json"

{"schema":"rtl-liberty-direct-map-report-0","mapped_cell_count":2,"total_area":"3.0"}

no direct Liberty cell covers generic kind के बाद कोई सेल प्रकार आने पर मेल खाते बूलियन फ़ंक्शन और धनात्मक area वाली लाइब्रेरी दें, फिर मैप कमांड दोबारा चलाएँ।

टार्गेट चयन और उसकी सोर्स फ़ाइलें जाँचें

टार्गेट-विश्लेषण कॉन्ट्रैक्ट और तैयारी रिकॉर्ड पढ़ें, फिर सोर्स फ़ाइल बंडल जाँचें। एडमिशन आपके चयन और सोर्स फ़ाइलों का डाइजेस्ट दर्ज करता है। स्ट्रक्चरल preflight डायग्नोस्टिक, कवरेज और हायरार्की परिणाम लौटाता है।

alti rtl target-analysis capabilities
alti rtl target-analysis readiness
jq '{schema:"rtl-source-bundle.v1",sources:[.request.sources[] | {path,text:.source}],roots:[.request.sources[].path],include_dirs:[],defines:[],tops:[.request.top]}' "$PROJECT/sim.json" > "$PROJECT/target-sources.json"
DEADLINE_MS="$(( $(date +%s) * 1000 + 60000 ))"
TARGET_ARGS=(--module top --top top --targets generic-asic --primary-target generic-asic
  --tools schematic,evidence --report-detail standard --profile local-example
  --cpu-slots 1 --memory-bytes 536870912 --max-wall-time-ms 5000
  --deadline-unix-ms "$DEADLINE_MS")
alti rtl target-analysis admit "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-admission.json"
jq -c '{schema, structuralPreflightAvailable}' "$PROJECT/target-admission.json"
alti rtl target-analysis preflight "${TARGET_ARGS[@]}" < "$PROJECT/target-sources.json" > "$PROJECT/target-preflight.json"
jq -r '.schema' "$PROJECT/target-preflight.json"

{"schema":"altifigence.rtl.target-analysis-direct-admission.v1","structuralPreflightAvailable":true}
altifigence.rtl.target-analysis-direct-result.v1

local-example इस उदाहरण में दर्ज किया गया प्रोफ़ाइल चयन है। tops को अनुरोधित --top के बराबर रखें। target Analysis source bundle is invalid: source/root/include/define/top cardinality is invalid आने पर जाँचें कि sources और roots में सोर्स फ़ाइल हो और tops में वही एक टॉप नाम हो।

चार-स्टेट सिमुलेशन कॉन्ट्रैक्ट चलाएँ

sim.json के सोर्स को समयबद्ध चार-स्टेट अनुरोध के साथ फिर इस्तेमाल करें। मान स्ट्रिंग 0, 1, X और Z हैं, सबसे कम महत्व वाला बिट पहले। इस उदाहरण में एक क्लॉक, एक रीसेट और समयबद्ध इनपुट शेड्यूल है।

jq '{schema:.schema,version:1,operationId:"altifigence.rtl.simulate.v2",request:{
  top:.request.top,sources:.request.sources,
  clocks:[{port:"clk",periodPs:1000,phasePs:500}],
  resets:[{port:"rst",activeLevel:"active_high",changes:[
    {timePs:0,valueLsb0:["1"]},{timePs:1000,valueLsb0:["0"]}]}],
  inputSchedules:[{port:"d",changes:[
    {timePs:0,valueLsb0:["0"]},{timePs:1000,valueLsb0:["1"]}]}],
  initialRegisterValues:["0"],
  limits:{maxCyclesPerClock:4,maxTimePs:4000,maxEvents:64}
}}' "$PROJECT/sim.json" > "$PROJECT/sim-v2.json"
alti rtl simulate-v2 admit --project "$PROJECT" sim-v2.json > "$PROJECT/v2-admission.json"
alti rtl simulate-v2 preflight --project "$PROJECT" sim-v2.json > "$PROJECT/v2-preflight.json"
alti rtl simulate-v2 run --project "$PROJECT" sim-v2.json > "$PROJECT/v2-result.json"
jq -r '.schema' "$PROJECT/v2-admission.json" "$PROJECT/v2-preflight.json"
jq -r '.artifact.payload.schema' "$PROJECT/v2-result.json"

altifigence.rtl.simulation-admission.v2
altifigence.rtl.simulation-preflight.v2
altifigence.rtl.simulation-receipt.v2

सुनिश्चित करें कि हर चरण का एग्ज़िट स्टेटस 0 हो। एडमिशन समयबद्ध अनुरोध जाँचता है; preflight उसकी सिंथेसाइज़ की गई नेटलिस्ट तैयार करता है; run ट्रेस, वेवफ़ॉर्म, सारांश और प्रोवेनेंस बनाता है। सम संख्या वाला periodPs और अवधि से छोटा phasePs इस्तेमाल करें।

CLI इंजन कमांड