From WCET to CI: Integrating RocqStat into Automotive Software Pipelines

Hook: Your CI pipeline runs green — but timing failures still reach the car

CPU-bound faults, missed deadlines and unexpected field resets are the nightmares of automotive firmware teams. Functional tests, unit coverage, and static analyzers are necessary, but they don’t guarantee timing safety. With Vector’s January 2026 acquisition of StatInf’s RocqStat and its planned integration into VectorCAST, teams now have a path to bring worst-case execution time (WCET) and timing analysis into automated CI/CD — not as an afterthought, but as a gated, continuous verification step.

Why timing analysis must be part of CI in 2026

Recent trends (late 2025–early 2026) make continuous timing verification mandatory for modern automotive projects:

• ADAS and domain controllers are more software-defined, increasing code complexity and timing variability.
• ISO 26262 and SOTIF enforcement continues to emphasize system-level timing guarantees for ASIL-relevant functions.
• Over-the-air updates and continuous deployment for vehicles demand automated safety gates to prevent regressions.
• Tool consolidation — Vector integrating RocqStat into VectorCAST — reduces friction for embedding timing tools in CI workflows.

Ignoring WCET until late-stage integration creates cost and schedule risk. The winning teams integrate timing checks early and automate them in CI/CD.

What RocqStat brings to VectorCAST — and why it matters

RocqStat (StatInf) specializes in advanced timing analysis and WCET estimation. Integrated into VectorCAST, it provides:

• Static and measurement-driven WCET with architecture-aware models (caches, pipelines).
• Path-sensitive analysis with annotations to constrain infeasible paths.
• Exportable reports and machine-readable outputs suited for pipelines.
• Expert heuristics for multicore interference and shared bus analysis.

Operationally this means you can make WCET a repeatable CI step, not a manual lab exercise.

Two integration strategies: CLI-first and VectorCAST-native

There are two pragmatic approaches depending on maturity and licensing:

1. CLI-first (fast, portable): Use RocqStat’s command-line interface or its service endpoint inside CI containers. Good for rapid adoption, reproducibility, and cross-vendor toolchains.
2. VectorCAST-native (full toolchain): When your organization standardizes on VectorCAST, use the VectorCAST integration that orchestrates build, test and timing analyses in one environment. Best for traceability and certification artifacts.

When to choose which

• Choose CLI-first for microservices-like CI jobs, reproducible containers, or polyglot build systems.
• Choose VectorCAST-native if you need unified reporting, stronger ALM traceability, and built-in test orchestration aligned with certification workbooks.

Practical architecture: how WCET fits into CI/CD

At a high level, add a timing-analysis stage after compilation and before integration. Typical pipeline stages:

1. Checkout & dependency install
2. Static analysis & build (cross-compile)
3. Unit tests & VectorCAST test execution
4. WCET / timing analysis (RocqStat)
5. Hardware-in-the-loop (HIL) / integration tests
6. Release gating & artifact promotion

Key CI inputs for accurate WCET

• Build artifacts with symbol and map files
• Processor model (pipeline, cache sizes), often provided to RocqStat
• Linker map to relate addresses to functions
• Annotations or assumptions about interrupt behavior and scheduling

Sample CI snippets (GitLab CI, Jenkinsfile, GitHub Actions)

Below are concise practical examples to get you started. Replace placeholders with your toolchain specifics and license details.

GitLab CI: wcet job

stages:
  - build
  - test
  - timing

build:
  stage: build
  script:
    - make CROSS_COMPILE=arm-none-eabi-
  artifacts:
    paths:
      - build/

unit_tests:
  stage: test
  script:
    - vectorcast-run --project proj.vc
  dependencies:
    - build

wcet_analysis:
  stage: timing
  image: myregistry/rocqstat:2026.1
  dependencies:
    - build
  script:
    - rocqstat analyze --binary build/firmware.elf --map build/firmware.map --cpu cortex-m4 --out wcet-results.json
    - python ci/parse_wcet.py wcet-results.json --threshold 1500us
  artifacts:
    paths:
      - wcet-results.json
    when: always
  allow_failure: false

Jenkinsfile: fail-fast on timing regressions

pipeline {
  agent any
  stages {
    stage('Build') { steps { sh 'make' } }
    stage('Unit') { steps { sh 'vectorcast-run --project proj.vc' } }
    stage('WCET') {
      steps {
        sh 'docker run --rm -v $PWD/build:/work rocqstat:2026 rocqstat analyze --binary /work/firmware.elf --map /work/firmware.map --cpu cortex-r5 --out /work/wcet.json'
        sh 'python ci/compare_wcet.py /work/wcet.json baseline/wcet_baseline.json'
      }
    }
  }
}

These examples assume a machine-readable wcet-results.json output. In practice, build a small parser to normalize RocqStat outputs so the CI job can compare, fail, or annotate PRs.

Practical steps to operationalize RocqStat in your pipeline

Follow these steps to make timing analysis reliable and actionable:

1. Baseline your system: Run RocqStat on a known release to capture per-function WCET and system-level budgets. Store baseline artifacts in a versioned artifact store.
2. Containerize the analyzer: Provide deterministic analysis by shipping RocqStat and CPU models in a container or reproducible environment image.
3. Automate mapping & symbol extraction: Ensure your build produces a canonical ELF/map file. The CI job must pass the same artifacts RocqStat needs for address resolution.
4. Define measurable gates: Create thresholds (absolute or regression %). For example, “no function’s WCET increases more than 5%” or “system WCET < 20ms.”
5. Store and visualize results: Publish JSON results to your dashboard, link to PRs, and keep historic trends for regression detection.
6. Establish triage playbooks: If timing fails, automatically block merges and create an issue with diffs and hot spots to accelerate debugging.

Example: simple gating script (Bash)

#!/usr/bin/env bash
NEW=$1
BASELINE=baseline/wcet_baseline.json
THRESHOLD=1.05   # 5% regression
python ci/compare_wcet.py "$NEW" "$BASELINE" "$THRESHOLD"
if [ $? -ne 0 ]; then
  echo "WCET regression detected: failing build"
  exit 1
fi

Dealing with multicore, caches and non-determinism

WCET in 2026 must account for modern SoC complexity:

• Multicore interference: Use RocqStat’s shared-resource models or measure interference patterns via controlled co-run experiments. Treat worst-case bus contention as an explicit budget in system-level checks.
• Cache and pipeline modeling: Accurate CPU models increase analysis precision. Keep CPU configuration files under source control and tie them to the build.
• Non-deterministic inputs: Use annotations to constrain infeasible paths. Measurement-driven WCET (hybrid analysis) can complement static analysis to reduce pessimism where safe.

Integration patterns for hardware-in-the-loop (HIL) and field test fusion

Static WCET is necessary but sometimes conservative. A hybrid approach combines RocqStat static estimates with measurement data:

• Run measurement profiles on HIL or instrumentation builds to capture observed maxima.
• Feed observed traces back into RocqStat’s measurement-driven mode to refine estimates where safe.
• In CI, gate static WCET but also run nightly measurement builds against representative hardware to improve confidence.

Alerting, triage and developer feedback

For timing to be effective it must be visible and actionable:

• Annotate PRs with the top 5 functions showing the largest WCET increases.
• Provide a diff view between baseline and PR WCET; include source line links to accelerate fixes.
• Integrate with Slack, MS Teams or Jira to auto-create tickets when thresholds are exceeded.

Data to store and metrics to track

Keep these metrics for trending and risk management:

• Per-function WCET and change % vs baseline
• System-level worst-case latency and utilization
• Analysis duration (time per WCET run) to budget CI resources
• Number of timing regressions per release and resolution lead time

Certification, traceability and audit artifacts

VectorCAST + RocqStat integration simplifies producing certification evidence:

• Export time-stamped analysis reports and attach them to change requests.
• Keep CPU model versions and build artifacts in the same ALM toolchain for reproducibility.
• Use VectorCAST traceability features to map test cases, requirements and timing reports for ISO 26262 workpapers.

Case study: hypothetical ADAS ECU pipeline

Consider a radar perception ECU (Cortex-M7 cores, ASIL B/C mixed-critical). The team implemented the following:

1. Baseline run with RocqStat on release v1.2 capturing system WCET = 12.6 ms.
2. Pipeline step added to run RocqStat CLI in a container; results saved to artifact storage.
3. PR gating rule: system WCET must remain < 13.5 ms and no per-function regression > 7%.
4. Nightly HIL runs produce measurement profiles that are used to update RocqStat’s hybrid mode each week.

Outcome: The team prevented two timing regressions during feature merges and reduced debug cycles by 40% thanks to automated hotspots and PR annotations.

Performance & cost considerations

WCET analysis can be compute-heavy. Practical tips:

• Run lightweight fast checks for PRs and reserve full analysis for merge/main or nightly runs.
• Parallelize function-level analysis across CI runners when supported.
• Cache CPU models and pre-processed control-flow graphs to reduce repeated computation.
• Budget cloud instances for heavy runs and use spot/ephemeral capacity where license policy allows.

Security, compliance and tooling governance

Treat timing analysis tools like any other build dependency:

• Manage RocqStat/VectorCAST licenses centrally; bake tokens into secure CI secrets managers.
• Keep CPU models and analysis configs in the same SCM as firmware for change control.
• Audit CI job outputs and store signed reports for compliance evidence.

2026 predictions: where this integration leads

• Unified verification platforms: Expect VectorCAST + RocqStat to accelerate end-to-end verification toolchains that merge functional and timing analysis into one workflow.
• Hybrid WCET becomes mainstream: Combining static and measurement-driven analysis will reduce pessimism while retaining rigor.
• Continuous certification evidence: Automated timing reports will be standard artifacts in certification pipelines and OTA approval workflows.
• Shift-left timing engineering: Developers will get immediate timing feedback in PRs, similar to unit test results.

“Timing safety is becoming a critical differentiator for software-defined vehicles.” — Vector announcement, January 2026

Common pitfalls and troubleshooting

Avoid these frequent mistakes:

• Running WCET only on final integration builds — too late for developer feedback.
• Undocumented CPU models or manual changes to cache settings — breaks reproducibility.
• Ignoring multicore interference or scheduling effects — can invalidate single-core assumptions.
• Failure to correlate symbol addresses to sources — makes triage slow and error-prone.

Checklist for teams starting today

• Obtain RocqStat/VectorCAST licenses and container images.
• Define baseline release and capture WCET artifacts.
• Add a deterministic CI job for RocqStat with artifact retention.
• Set provisional gates (e.g., 5% regression) and refine after a few sprints.
• Integrate PR annotation and automatic ticket creation for regressions.
• Plan nightly HIL measurement runs and hybrid analysis feed-back loops.

Final takeaways

Bringing RocqStat into automated CI/CD is not just a tooling upgrade — it’s an operational shift. By making WCET and timing analysis routine, you reduce late-stage surprises, accelerate developer feedback, and create auditable evidence for safety certification. With Vector’s acquisition and roadmap in 2026, teams have the chance to bake timing safety into the pipeline the same way they treat unit tests or linters.

Call-to-action

If you’re responsible for automotive firmware verification, start a pilot this sprint: containerize RocqStat, run it on a stable baseline, add a CI job for PRs, and set conservative gating thresholds. For a hands-on workshop, reach out to bigthings.cloud for a 2-day private lab where we’ll containerize RocqStat, integrate it into your GitLab/GitHub/Jenkins pipeline, and create baseline reports and PR annotations tailored to your stack.

Related Reading

• 34" Alienware AW3423DWF OLED: Deep Dive Into the 50% Off Deal
• Keep Deliveries Toasty: Using Rechargeable Heat Packs vs Insulated Bags
• Consolidate or Cut: How to Decide If Your Cloud Toolstack Has Gone Too Far
• Using Total Campaign Budgets in Google Search: An Audit-Driven Playbook for Seasonal Spend
• Netflix Pulls Casting — What It Means for Device Makers and Streaming UX