# CLI reference Command help from the checked repository snapshots. Run `helx COMMAND --help` for your installed version. ## helx build ```text Usage: helx build [OPTIONS] {plan} Build a frozen runner without invoking FVP and save a new compiled-build record. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * plan A saved frozen local plan JSON. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ * --output -o A new compiled-build directory; parent must exist. [required] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx build local/case.plan.json -o local/case-build ``` ## helx cache ```text Usage: helx cache [OPTIONS] COMMAND [ARGS]... Inspect or clear the cache of downloaded models. The FVP and toolchain cache is separate (helx doctor). ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮ │ info Where downloaded models live and how much space they take. │ │ clear Delete every downloaded model; the next run fetches again. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` ## helx cache clear ```text Usage: helx cache clear [OPTIONS] Delete every downloaded model; the next run fetches again. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --model-cache-dir Model cache root to inspect (default: the shared cache │ │ under ~/.cache/helia-estimator). │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx cache clear ``` ## helx cache info ```text Usage: helx cache info [OPTIONS] Where downloaded models live and how much space they take. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --model-cache-dir Model cache root to inspect (default: the shared cache │ │ under ~/.cache/helia-estimator). │ │ --json Print as JSON. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx cache info --json ``` ## helx doctor ```text Usage: helx doctor [OPTIONS] Check the host: Python, Vela, LiteRT and the platforms, then the FVP, toolchain and runtime sources for the target. Never raises. Says whether Vela-only runs and FVP runs are possible and what to do about anything missing. Exit code is 0 unless --strict. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --target FVP subsystem the FVP checks are for: corstone-320 or corstone-300. │ │ [default: corstone-320] │ │ --json Print the report as JSON. │ │ --strict Exit 1 when a required check for the target is missing (default: always │ │ 0). │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx doctor helx doctor --json | jq .fvp_ready helx doctor --strict && helx run --config my.yaml ``` ## helx export ```text Usage: helx export [OPTIONS] {paths}... Collect every result bundle under the given paths into one table: by default the fields a reader compares runs by (latency, energy, footprint, what the numbers rest on), or every field of every bundle with --fields all. Bundles that ran on the FVP fill the measured columns; Vela-only bundles leave them empty. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * paths Bundle directories, their run_summary.json, or parents to search. │ │ [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --strict Fail on a bundle that does not load instead of skipping it with a note. │ │ --verbose -v Name every bundle that was skipped instead of counting them. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Output ─────────────────────────────────────────────────────────────────────────────────────────╮ │ --fields summary: per-sample comparisons; all: per-sample leaves; statistics: one │ │ aggregate row per bundle. │ │ [default: summary] │ │ --format table, csv or json. [default: table] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx export results/ helx export results/ --format csv > runs.csv helx export results/kws_* --fields all --format json ``` ## helx freeze ```text Usage: helx freeze [OPTIONS] Save a format-2 local replay plan with checked input files and requirements. Downloads and runs nothing. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ * --config -c A version-2 experiment YAML. [required] │ │ * --output -o New plan JSON outside results and workspace. [required] │ │ --model Use this local model instead of the config source. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx freeze -c case.yaml -o local/case.plan.json --model local/model.tflite ``` ## helx ```text Usage: helx [OPTIONS] COMMAND [ARGS]... heliaEstimator (helx): compile a LiteRT model for the Ethos-U NPU, run it on the Corstone FVP, and turn the PMU counters into cycles and energy for an Ambiq SoC. One config is one experiment and writes one result bundle. Start with helx doctor to check the host, then helx run --config examples/at110/kws_vela_only.yaml. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --version -V Print the helx version and exit. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮ │ run Run one experiment from a config and write its result bundle. The bundle lands in the │ │ config's run.results_dir as run_summary.json, .csv and .md plus manifest.json and │ │ artifacts/. Vela-only configs need no FVP. FVP configs need Arm's FVP licence │ │ accepted once through helx setup; the rest is fetched on first use. │ │ run-case Run one case from flags instead of a config file. Writes the equivalent config.yaml │ │ into the run root, then runs it exactly as helx run would. Handy for a quick look at │ │ one model; use a config for anything you want to keep. With no flags it runs the │ │ public KWS reference model on at110 in ULP. │ │ doctor Check the host: Python, Vela, LiteRT and the platforms, then the FVP, toolchain and │ │ runtime sources for the target. Never raises. Says whether Vela-only runs and FVP │ │ runs are possible and what to do about anything missing. Exit code is 0 unless │ │ --strict. │ │ show Show one result bundle: the run and its hardware-values status, measured cycles, │ │ memory traffic, experimental energy per mode, memory footprints, Vela's estimates, │ │ sanity and the costliest layers. │ │ export Collect every result bundle under the given paths into one table: by default the │ │ fields a reader compares runs by (latency, energy, footprint, what the numbers rest │ │ on), or every field of every bundle with --fields all. Bundles that ran on the FVP │ │ fill the measured columns; Vela-only bundles leave them empty. │ │ setup Download and verify the FVP, the Arm toolchain and the runtime sources. Everything │ │ lands under the cache root (helx cache info) and is recorded in a │ │ runtime.SUBSYSTEM.env file that FVP runs read. The FVP is installed or used only │ │ after you accept Arm's licence for it, which this command shows and asks for once. │ │ helx run fetches everything else on demand but never asks for the licence. Prints the │ │ environment file's KEY=VALUE lines. │ │ support List registered runtime/FVP runner contracts without checking this host or running │ │ models. │ │ freeze Save a format-2 local replay plan with checked input files and requirements. │ │ Downloads and runs nothing. │ │ replay Verify and replay a saved local plan through the normal pipeline. Refuses input or │ │ software drift. │ │ build Build a frozen runner without invoking FVP and save a new compiled-build record. │ │ run-build Run a retained compiled runner without compiling or building it again. │ │ cache Inspect or clear the cache of downloaded models. The FVP and toolchain cache is │ │ separate (helx doctor). │ │ platform The hardware definitions helx runs against: an SoC (NPU, memories, clocks) plus an │ │ energy model, with a provenance status on every number. │ │ validate Check an input or a result bundle without running anything: the same validation helx │ │ run, helx platform show and helx show apply, as one line or one JSON document. Exit 1 │ │ when invalid. │ │ results Inspect verified bundles and export portable draft JSON without running tools. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Exit codes: 0 success, 1 a helx error (config, platform, model, Vela, FVP), 2 usage, 130 interrupted. Docs: README.md, AGENTS.md, docs/reference/ (config and results), docs/npu_estimation_methodology.md. ``` ## helx platform ```text Usage: helx platform [OPTIONS] COMMAND [ARGS]... The hardware definitions helx runs against: an SoC (NPU, memories, clocks) plus an energy model, with a provenance status on every number. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮ │ show Print a platform: memories, modes, energy values and where each number came │ │ from. Every value carries a status: confirmed (measured or reviewed against │ │ measurements), fitted (tuned so the model reproduces RTL or FPGA), or │ │ unverified (spec, estimate, placeholder). Values whose status differs from │ │ their block's are listed under it. │ │ list List the shipped platforms. │ │ export-vela-ini Write the Vela system config (.ini) helx generates for a platform and mode. │ │ This is the exact file a run hands to Vela, so it can be used to compile │ │ outside helx. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` ## helx platform export-vela-ini ```text Usage: helx platform export-vela-ini [OPTIONS] {platform} Write the Vela system config (.ini) helx generates for a platform and mode. This is the exact file a run hands to Vela, so it can be used to compile outside helx. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * platform A shipped platform name (helx platform list) or a path to a platform │ │ YAML. │ │ [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --mode Operating mode section to export (default: the first mode). │ │ --output -o Write here instead of stdout. │ │ --placement Where weights, arena and Vela's cache live, as CONST,ARENA,CACHE │ │ physical memory names (helx platform show lists them), e.g. │ │ psram,ssram,ssram. Decides which memory each port carries in the │ │ file (default: each port's first). │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx platform export-vela-ini at110 --mode HP -o at110_hp.ini helx platform export-vela-ini at110 --mode HP --placement psram,ssram,ssram ``` ## helx platform list ```text Usage: helx platform list [OPTIONS] List the shipped platforms. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print the names as a JSON list. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx platform list --json ``` ## helx platform show ```text Usage: helx platform show [OPTIONS] {platform} Print a platform: memories, modes, energy values and where each number came from. Every value carries a status: confirmed (measured or reviewed against measurements), fitted (tuned so the model reproduces RTL or FPGA), or unverified (spec, estimate, placeholder). Values whose status differs from their block's are listed under it. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * platform A shipped platform name (helx platform list) or a path to a platform │ │ YAML. │ │ [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --verbose -v Also print the per-mode derived timing and the revision history. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx platform show at110 helx platform show at110 --verbose ``` ## helx replay ```text Usage: helx replay [OPTIONS] {plan} Verify and replay a saved local plan through the normal pipeline. Refuses input or software drift. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * plan A saved helx.frozen-run format-2 JSON plan. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --verbose -v Show stage progress; -vv shows detailed logs. [default: 0] │ │ --quiet -q Print only errors. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx replay local/case.plan.json helx replay local/case.plan.json -q ``` ## helx results ```text Usage: helx results [OPTIONS] COMMAND [ARGS]... Inspect verified bundles and export portable draft JSON without running tools. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮ │ inspect Print a draft JSON inspection; invalid/incomplete evidence returns exit 1. │ │ show Print one portable draft JSON view after native evidence verification. │ │ export Write portable draft JSON to a new file outside the source bundle. │ │ artifacts List retained Model Explorer/Perfetto artifacts and their experiment meaning as │ │ JSON. │ │ export-artifact Copy a retained viewer artifact to a new file outside the verified bundle. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx results inspect results/kws_vela_only helx results show results/kws_vela_only --format json helx results export results/kws_vela_only --output portable-result.json ``` ## helx results artifacts ```text Usage: helx results artifacts [OPTIONS] {location} List retained Model Explorer/Perfetto artifacts and their experiment meaning as JSON. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * location Bundle directory or run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --format Artifact catalog format. [default: json] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx results artifacts results/kws_bus_trace --format json ``` ## helx results export-artifact ```text Usage: helx results export-artifact [OPTIONS] {location} Copy a retained viewer artifact to a new file outside the verified bundle. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * location Bundle directory or run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ * --artifact Relative path from the viewer catalog. [required] │ │ * --output -o New destination file. [required] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx results export-artifact results/kws_bus_trace --artifact artifacts/bus_trace_perfetto.json --output timeline.json ``` ## helx results export ```text Usage: helx results export [OPTIONS] {location} Write portable draft JSON to a new file outside the source bundle. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * location Bundle directory or run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ * --output -o New JSON destination. [required] │ │ --format Portable result format. [default: json] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx results export results/kws_vela_only --output portable-result.json ``` ## helx results inspect ```text Usage: helx results inspect [OPTIONS] {location} Print a draft JSON inspection; invalid/incomplete evidence returns exit 1. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * location Bundle directory or run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --format Portable inspection format. [default: json] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx results inspect results/kws_vela_only --format json ``` ## helx results show ```text Usage: helx results show [OPTIONS] {location} Print one portable draft JSON view after native evidence verification. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * location Bundle directory or run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --format Portable result format. [default: json] │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Example: helx results show results/kws_vela_only --format json ``` ## helx run-build ```text Usage: helx run-build [OPTIONS] {record} Run a retained compiled runner without compiling or building it again. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * record A verified compiled-build directory. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ * --output -o A new native result directory; parent must exist. [required] │ │ --verbose -v Show stage progress; -vv shows logs. [default: 0] │ │ --quiet -q Print only errors. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx run-build local/kws-build -o results/kws-from-build helx run-build local/kws-build -o results/another-run -q ``` ## helx run-case ```text Usage: helx run-case [OPTIONS] Run one case from flags instead of a config file. Writes the equivalent config.yaml into the run root, then runs it exactly as helx run would. Handy for a quick look at one model; use a config for anything you want to keep. With no flags it runs the public KWS reference model on at110 in ULP. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ What to run ────────────────────────────────────────────────────────────────────────────────────╮ │ --model Model source: a local .tflite path, an https URL or an s3 URL. │ │ [default: │ │ https://ambiqai-model-zoo.s3-us-west-2.amazonaws.com/helia-estimato… │ │ --model-name Name recorded in the results (default: the model file's stem). │ │ --memory-mode Vela memory mode: Sram_Only, Shared_Sram or Dedicated_Sram. │ │ [default: Shared_Sram] │ │ --placement Where weights, arena and Vela's cache live, as CONST,ARENA,CACHE │ │ physical memory names (helx platform show lists them), e.g. │ │ psram,ssram,ssram. Replaces --memory-mode. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Output ─────────────────────────────────────────────────────────────────────────────────────────╮ │ --run-root Where the bundle goes (default: │ │ results/pipeline_case_TIMESTAMP/ in the current │ │ directory). │ │ --discard-workspace Remove the build workspace after the run. │ │ --keep-debug-artifacts Keep the .axf and the FVP logs next to the results. │ │ --json Print only a JSON object with the result paths and │ │ status. │ │ --verbose -v -v: one line per stage with its time and INFO logs; │ │ -vv: every log line with file and line. │ │ [default: 0] │ │ --quiet -q Print nothing but errors; the bundle is still │ │ written. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Platform ───────────────────────────────────────────────────────────────────────────────────────╮ │ --platform A shipped platform name (helx platform list) or a platform YAML │ │ path. │ │ [default: at110] │ │ --platform-mode NPU operating mode of the platform, for example ULP or HP. │ │ [default: ULP] │ │ --arena-cache-size Bytes of port-0 memory Vela may use for the arena and its │ │ weight cache. │ │ [default: 1048576] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ FVP run ────────────────────────────────────────────────────────────────────────────────────────╮ │ --runtime-engine Runtime linked into the FVP runner: │ │ litert, tflm, tflite-micro, │ │ upstream-tflm, helia-rt, heliaRT, │ │ helia-aot, heliaAOT, aot. │ │ [default: litert] │ │ --helia-rt-backend Kernel backend when the runtime is │ │ heliaRT: helia-core (aliases: │ │ helia, heliacore, ns-cmsis-nn, │ │ nsx-cmsis-nn); heliaRT supports │ │ heliaCORE only; use runtime_engine: │ │ litert for Arm CMSIS-NN. │ │ --pmu-profile [default: default] │ │ --simlimit FVP simulation time limit in │ │ seconds. │ │ [default: 300] │ │ --vela-only Compile with Vela and stop; no FVP │ │ build or run. │ │ --no-fvp-run Build the FVP runner but do not run │ │ it. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx run-case --model local/models/my_model.tflite --memory-mode Sram_Only --vela-only helx run-case --platform at110 --platform-mode HP --pmu-profile port_stall --json helx run-case --platform at110 --placement psram,ssram,ssram --vela-only ``` ## helx run ```text Usage: helx run [OPTIONS] Run one experiment from a config and write its result bundle. The bundle lands in the config's run.results_dir as run_summary.json, .csv and .md plus manifest.json and artifacts/. Vela-only configs need no FVP. FVP configs need Arm's FVP licence accepted once through helx setup; the rest is fetched on first use. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ What to run ────────────────────────────────────────────────────────────────────────────────────╮ │ * --config -c A version: 2 YAML config: one model, one placement, │ │ one platform and mode. │ │ [required] │ │ --model Replace the config's model source: a local path, an │ │ https URL or an s3 URL. │ │ --model-cache-mode persistent keeps a downloaded model in the shared │ │ cache; ephemeral uses a temporary directory. │ │ [default: persistent] │ │ --model-cache-dir Cache root for downloaded models (default: helx │ │ cache info). │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Output ─────────────────────────────────────────────────────────────────────────────────────────╮ │ --verbose -v -v: one line per stage with its time and INFO logs; -vv: every log │ │ line with file and line. │ │ [default: 0] │ │ --quiet -q Print nothing but errors; the bundle is still written. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx run --config examples/at110/kws_vela_only.yaml helx run --config examples/at110/kws_litert.yaml --model local/models/my_model.tflite ``` ## helx setup ```text Usage: helx setup [OPTIONS] Download and verify the FVP, the Arm toolchain and the runtime sources. Everything lands under the cache root (helx cache info) and is recorded in a runtime.SUBSYSTEM.env file that FVP runs read. The FVP is installed or used only after you accept Arm's licence for it, which this command shows and asks for once. helx run fetches everything else on demand but never asks for the licence. Prints the environment file's KEY=VALUE lines. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ FVP run ────────────────────────────────────────────────────────────────────────────────────────╮ │ --target FVP subsystem to prepare: corstone-320 (Ethos-U85, AT110) │ │ or corstone-300 (Ethos-U55 and U65). │ │ [default: corstone-320] │ │ --skip-fvp-download Fail instead of downloading when the FVP archive is not │ │ already cached. │ │ --force Reinstall every managed dependency even if present. │ │ --accept-arm-fvp-licence Accept Arm's licence for the Corstone FVP without a │ │ prompt (for scripts and CI). Without it, helx setup shows │ │ where the licence is and asks; the environment variable │ │ HELX_ACCEPT_ARM_FVP_LICENCE=1 does the same. │ │ --allow-dirty-checkouts Accept locally modified dependency checkouts (for │ │ deliberate experiments only). │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx setup helx setup --target corstone-300 helx setup --accept-arm-fvp-licence # scripts and CI ``` ## helx show ```text Usage: helx show [OPTIONS] {path} Show one result bundle: the run and its hardware-values status, measured cycles, memory traffic, experimental energy per mode, memory footprints, Vela's estimates, sanity and the costliest layers. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * path A result bundle directory or its run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Output ─────────────────────────────────────────────────────────────────────────────────────────╮ │ --layers -n How many of the costliest layers to list (0 for none). [default: 5] │ │ --json Print the validated run_summary.json instead of tables. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx show results/kws_vela_only helx show results/kws_vela_only --layers 10 helx show results/kws_vela_only --json | jq .energy ``` ## helx support ```text Usage: helx support [OPTIONS] List registered runtime/FVP runner contracts without checking this host or running models. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one static support JSON document. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx support helx support --json ``` ## helx validate ```text Usage: helx validate [OPTIONS] COMMAND [ARGS]... Check an input or a result bundle without running anything: the same validation helx run, helx platform show and helx show apply, as one line or one JSON document. Exit 1 when invalid. ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Commands ───────────────────────────────────────────────────────────────────────────────────────╮ │ config Check a version 2 config as helx run would before compiling: schema, platform and │ │ mode, target, the NPU's Vela accelerator, the FVP it runs on, PMU program and │ │ placement, and that a local model exists. Downloads and runs nothing; the machine │ │ itself is helx doctor's. │ │ platform Load a platform by shipped name or path: SoC reference, energy model, provenance and │ │ history. │ │ bundle Parse a result bundle's run_summary.json against the schema helx show reads, check │ │ that every file it names exists, and recompute the manifest's sizes and hashes. │ │ frozen Verify a saved format-2 local replay plan and its declared inputs without running │ │ tools. │ │ build Verify a retained compiled-build record and native build evidence without running │ │ tools. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ``` ## helx validate build ```text Usage: helx validate build [OPTIONS] {path} Verify a retained compiled-build record and native build evidence without running tools. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * path A compiled-build directory or build_record.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one JSON document (kind, path, valid, summary or error) instead of a line; │ │ exit 1 when invalid. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx validate build local/case-build --json ``` ## helx validate bundle ```text Usage: helx validate bundle [OPTIONS] {path} Parse a result bundle's run_summary.json against the schema helx show reads, check that every file it names exists, and recompute the manifest's sizes and hashes. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * path A result bundle directory or its run_summary.json. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one JSON document (kind, path, valid, summary or error) instead of a line; │ │ exit 1 when invalid. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx validate bundle results/kws_vela_only helx validate bundle results/kws_vela_only --json ``` ## helx validate config ```text Usage: helx validate config [OPTIONS] {path} Check a version 2 config as helx run would before compiling: schema, platform and mode, target, the NPU's Vela accelerator, the FVP it runs on, PMU program and placement, and that a local model exists. Downloads and runs nothing; the machine itself is helx doctor's. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * path The config YAML. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one JSON document (kind, path, valid, summary or error) instead of a line; │ │ exit 1 when invalid. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx validate config examples/at110/kws_vela_only.yaml helx validate config local/my_case.yaml --json ``` ## helx validate frozen ```text Usage: helx validate frozen [OPTIONS] {path} Verify a saved format-2 local replay plan and its declared inputs without running tools. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * path The saved plan JSON. [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one JSON document (kind, path, valid, summary or error) instead of a line; │ │ exit 1 when invalid. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx validate frozen local/case.plan.json --json ``` ## helx validate platform ```text Usage: helx validate platform [OPTIONS] {platform} Load a platform by shipped name or path: SoC reference, energy model, provenance and history. ╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────╮ │ * platform A shipped platform name (helx platform list) or a path to a platform │ │ YAML. │ │ [required] │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮ │ --json Print one JSON document (kind, path, valid, summary or error) instead of a line; │ │ exit 1 when invalid. │ │ --help Show this message and exit. │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯ Examples: helx validate platform at110 helx validate platform local/platforms/at110_fast.yaml --json ```