automotivesafetyCI/CD

From Timing Analysis to Safer AV Software: What Vector’s RocqStat Buy Means for Real-Time AI

UUnknown

2026-03-04

9 min read

How Vector's RocqStat acquisition unifies WCET and verification for automotive AI and how to adopt it in CI/CD.

Hook: Why timing analysis is the missing piece for deployment speed and safety

If your team ships automotive AI that misses latent timing problems only after integration testing or, worse, in the field, you know the cost: delayed releases, rework across software and hardware teams, and messy certification evidence. In 2026 the challenge has multiplied — embedded ML workloads, mixed-criticality ECUs, and heterogenous NPUs mean functional correctness is no longer sufficient. You must prove bounded latency and provide traceable timing evidence for safety cases. Vector's January 2026 acquisition of RocqStat and the announced plan to fold it into VectorCAST changes the game: it promises a unified environment that closes the gap between worst-case execution time (WCET) analysis and conventional software verification.

Executive summary: What this integration delivers

In short, combining RocqStat with VectorCAST creates a single toolchain where functional testing, code coverage, and timing analysis are linked to the same build artifacts and traceability models. That means:

Automated WCET estimation tied to test suites and coverage metrics
Traceable timing artifacts for ISO 26262 and SOTIF safety cases
CI/CD gates that enforce timing budgets as code and models evolve
Faster iterative workflows for embedded ML developers: change a network, run quantized build, get WCET delta within minutes

Context: Why timing problems are urgent in 2026

Late 2025 and early 2026 saw two reinforcing trends that make timing analysis essential:

Explosion of embedded ML across perception, sensor fusion, and inference at the edge — pushing more code into real-time deadlines.
Widespread heterogenous architectures: MCUs, multi-core CPUs, domain-specific NPUs and DL accelerators that introduce new sources of variance and contention.

Regulators and OEMs now demand not just functional correctness, but demonstrable timing safety. For automotive teams aiming for ASIL-B and above, that requires WCET evidence that is tied to the same test and version control artifacts used for verification.

What RocqStat brings to VectorCAST — technical capabilities and synergy

RocqStat specializes in timing analysis and WCET estimation. Integrated into VectorCAST, it delivers several complementary capabilities:

Source-aware WCET estimation: path analysis that maps timing estimates back to source-level constructs and tests.
Measurement-based and static analysis hybrids: use measurements to calibrate models, then apply static analysis for conservative upper-bounds.
Hardware-aware modeling: cache, pipeline and bus contention models needed for modern automotive SoCs and NPUs.
Traceability and reports: timing evidence embedded in verification reports for certification artifacts.

Why the unified approach matters

Separating WCET tools from test harnesses creates friction: different build configs, mismatched binaries, and difficulty correlating failing tests to timing regressions. With RocqStat inside VectorCAST you can use the same build artifact, exercise the same test cases you already use for functional verification, and produce timing results tied to those exact tests. That yields reproducible WCET evidence suitable for audits and faster feedback loops in CI.

Practical: Adopting VectorCAST + RocqStat in your CI/CD pipeline — a step-by-step plan

The following adoption plan is pragmatic and aimed at teams responsible for safety-critical AV stacks and embedded ML. It assumes VectorCAST and RocqStat CLI or APIs are available in your toolchain; adjust commands to match your environment.

Phase 0 — Planning and success criteria

Identify timing-critical paths and requirements. Map them to explicit timing requirements and ASIL levels.
Choose representative hardware targets: development PC for fast iteration and golden ECU/HIL for final validation.
Define gating policies: maximum WCET per function/module and acceptable regression thresholds (e.g., 5% increase fails pipeline).
Allocate a 4–8 week pilot for one ECU/inference function to produce reproducible results for certification stakeholders.

Phase 1 — Instrumentation and baseline

Standardize the build: create reproducible build recipes for both host and target (static linking, fixed compiler flags).
Integrate VectorCAST test harnesses for unit and integration tests of the ML inference stack.
Run RocqStat on the current baseline to produce initial WCET estimates tied to each VectorCAST test case.
Produce a baseline report and store WCET artifacts in your artifact repository alongside test coverage results.

Phase 2 — Automation: CI/CD pipeline design

Design the pipeline with clear stages. Example stages follow; adapt to GitHub Actions, GitLab CI, or Jenkins.

stages:
  - build
  - unit-test
  - vectorcast
  - rocqstat
  - report

build:
  script:
    - ./build.sh --target=ecu1

unit-test:
  script:
    - ./run_unit_tests.sh

vectorcast:
  script:
    - vectorcast-cli run-suite --suite=svc_inference_suite --output=vc_results.xml

rocqstat:
  script:
    - rocqstat-cli analyze --binary=build/ecu1.elf --tests=vc_results.xml --output=rocq_results.json
    - python tools/check_wcet_gates.py rocq_results.json --threshold-config=wcet-thresholds.json

report:
  script:
    - ./generate_combined_report.sh vc_results.xml rocq_results.json

The key point: make RocqStat analysis a first-class CI stage that consumes the same test results VectorCAST produces.

Phase 3 — Gating and regression detection

Implement automatic gating:

Fail the pipeline if any WCET item exceeds configured thresholds.
Introduce soft gates for exploratory branches where timing budgets are relaxed, with a mandatory follow-up to harden the budget before merge.
Record historical WCET values and plot trends; detect slow drifts that indicate accumulating technical debt.

# tools/check_wcet_gates.py (conceptual)
import sys
import json

def main():
    rocq = json.load(open(sys.argv[1]))
    thresholds = json.load(open(sys.argv[3]))
    for fn in rocq['entries']:
        name = fn['name']
        wcet = fn['wcet_us']
        thresh = thresholds.get(name, thresholds.get('default'))
        if wcet > thresh:
            print('WCET gate failed:', name, wcet, '>', thresh)
            sys.exit(2)
    print('All WCET gates passed')

if __name__ == '__main__':
    main()

Addressing embedded ML-specific challenges

ML inference has unique timing sources of nondeterminism. Here are practical strategies:

Deterministic runtimes: Lock down inference runtimes — fixed kernels, disabled dynamic kernel selection, pinned CPU affinities, and deterministic memory allocators.
Hardware modeling: Use RocqStat’s hardware-aware models for caches and buses when possible. For NPUs, combine vendor-provided latency models with conservative static bounds.
Controlled inputs: Generate adversarial or worst-case input sets (large activations, maximal branching) to exercise slow paths.
Quantized model testing: Run WCET analysis on the actual quantized binary that will be deployed; differences between float and int8 implementations can materially change timing.
Layer-level timing budgets: Break down WCET per layer to localize regressions when retraining or pruning models.

Certification and traceability: producing audit-ready artifacts

Integrating RocqStat outputs into VectorCAST reports closes the traceability loop auditors demand:

Link WCET estimates to requirements and to the exact VectorCAST test case that exercised the path.
Store deterministic build recipes, binary checksums, and golden ECU/HIL logs as part of the artifact bundle.
Document model versions, quantization settings, and runtime configs used for timing analysis.

This unified evidence package — functional test results, coverage, and timing proofs — directly supports ISO 26262 safety cases and SOTIF arguments for ML components.

Operational tips and advanced strategies

Shift-left WCET checks: Run fast, conservative timing analysis in pre-merge checks; run deeper, hardware-in-the-loop analyses nightly or for release candidates.
Statistical budgets: For functions with large variability, use probabilistic WCET (pWCET) in addition to conservative WCET to inform system-level scheduling tradeoffs.
Model partitioning: Where timing budgets are tight, split models across ECUs or pipelines so the longest-latency component is bounded and easier to certify.
HIL regression suites: Periodically validate CI WCET results against golden hardware logs. Discrepancies point to missing hardware effects in the model.
Metrics to track: per-function WCET, 95/99th latency percentiles, coverage-to-WCET correlation, and change frequency of timing-critical functions.

Case study (compact): perception inference on a production ECU

Example team: mid-sized OEM supplier running a quantized vision CNN on a multi-core SoC. Baseline problems: intermittent schedule overruns under high bus load; separate teams for ML and firmware.

What they did:

Integrated VectorCAST unit and integration tests for the inference stack.
Added RocqStat analysis to nightly pipelines; used cache and bus models calibrated by vendor-provided HIL measurements.
Defined hardened timing budgets per layer and an overall WCET limit for the inference function.
Automated gating: ML PRs that changed model topology or precision were blocked if per-layer WCET increased more than 3%.

Outcome: faster detection of regressions, a 40% reduction in late-stage integration bugs, and clear audit trails making ASIL-B approval smoother.

Predictions for real-time AI toolchains in 2026 and beyond

Expect these developments through 2026:

More integrated toolchains where timing analysis is native to test platforms rather than an afterthought.
Improved accelerator models and vendor collaboration to reduce the gap between static WCET estimates and hardware measurements.
Greater use of hybrid analysis (measurement + static) and pWCET to manage uncertainty in ML workloads.
CI/CD pipelines that enforce timing budgets as rigorously as unit tests — shifting the culture toward continuous timing safety.

"Timing safety is becoming a critical requirement for software-defined industries; unified toolchains will accelerate delivery while preserving certifiable evidence." — industry observation, January 2026

Actionable takeaways

Start with a single critical function and instrument it end-to-end in VectorCAST + RocqStat to rapidly prove value.
Automate WCET checks in CI with strict gating for safety-critical branches and soft gates for experimental work.
Calibrate models against golden hardware and record calibration artifacts for audits.
Make timing evidence part of your PR workflow: require WCET deltas to be displayed in merge requests.
Track trends: monitor WCET drift over time to prevent latent regressions.

Next steps: a 4-week pilot checklist

Week 1: Define timing requirements, select pilot ECU/function, install VectorCAST and RocqStat toolchain in CI.
Week 2: Create reproducible builds, run baseline tests, and generate baseline WCET report.
Week 3: Automate CI stages, implement WCET gates, and set up reporting dashboards.
Week 4: Validate against golden hardware, document artifacts for safety assessors, and prepare a go/no-go recommendation for broader rollout.

Final thoughts and call-to-action

Vector's acquisition of RocqStat marks a practical turning point: it takes timing analysis from a siloed, expert-only task to a CI-integrated, repeatable engineering discipline. For teams building safety-critical automotive AI, that means less late-stage surprise, clearer certification evidence, and faster iteration cycles. The clear next move is to run a focused pilot: integrate RocqStat analysis with your VectorCAST verification for a single inference function, automate WCET gates in CI, and use the resulting traceable artifacts to accelerate your safety case.

Ready to pilot: pick a timing-critical function, allocate a 4-week sprint as outlined above, and instrument your CI to fail on timing regressions. If you need a checklist or a sample pipeline adapted to GitHub Actions or GitLab CI, export your current build scripts and test suites and start with the example pipeline above.

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.