embeddedci-cdtesting

Timing Analysis Meets CI: Integrating RocqStat/VectorCAST into Embedded Pipelines

UUnknown

2026-03-21

10 min read

Automate WCET and timing verification with RocqStat + VectorCAST in CI for automotive and embedded projects — pipeline patterns, configs, and gating rules.

Hook: Your CI pipeline catches functional regressions — but what about timing?

In 2026, automotive and embedded teams ship software that controls brakes, steering, and powertrains where a missed deadline can be a safety fault. Yet many CI/CD pipelines still only run unit and integration tests. Timing regressions — increases in Worst-Case Execution Time (WCET) — are invisible until late-stage testing or field failure. That gap drives rework, certification delays, and risk.

This article shows how to automate WCET and timing verification inside CI/CD using the newly integrated RocqStat technology within Vector's VectorCAST ecosystem (following Vector's Jan 2026 acquisition of RocqStat). You'll get pragmatic pipeline patterns, sample CI configs, gating rules, and operational advice for automotive and embedded projects that must validate timing continuously.

Why timing in CI matters in 2026

By late 2025 and into 2026 the industry has accelerated software-defined vehicle development, multicore SoCs, and over-the-air updates. That means:

More frequent code changes that can affect execution paths and timing.
Multicore interference and complex cache hierarchies that make run-time behavior less predictable.
Tighter regulatory and functional safety scrutiny (ISO 26262, ISO/PAS trends) where timing verification is part of evidence for ASIL D systems.

The Vector + RocqStat union creates a more unified story: software verification (VectorCAST) and timing analysis (RocqStat) can now be combined into automated pipelines so timing checks are first-class CI citizens.

Vector announced the acquisition of RocqStat in January 2026 to integrate timing analysis and WCET estimation into its VectorCAST toolchain, enabling unified timing and verification workflows.

High-level pipeline pattern: where timing fits

Integrate timing analysis into CI as a dedicated stage immediately after deterministic test execution. A practical pipeline looks like this:

Checkout & toolchain setup (pin compilers and tools in Docker)
Build (cross-compile, produce ELF/binaries)
Unit & component tests (VectorCAST on host/QEMU/target)
Trace collection / execution path capture (from VectorCAST)
WCET analysis (RocqStat using binaries + trace/CFG + platform timing model)
Report & gating (fail CI on budget breach or regression)
Artifact publish & attach timing evidence for certification

Why this ordering?

Run functional tests first to exercise realistic execution paths and produce coverage/trace artifacts that improve WCET estimates. Combining VectorCAST-generated test vectors with RocqStat's static analysis produces tighter, evidence-based WCETs than blind static-only approaches.

Key building blocks and responsibilities

VectorCAST: automated unit/component/system testing and test-data generation. Run in CI to exercise code paths deterministically.
RocqStat: WCET and timing analysis engine that consumes binaries, CFGs, and platform timing models (caches, pipelines), and optionally execution traces to refine estimates.
Timing model repository: store per-SoC models (pinned versions) as artifacts in version control or an internal registry.
CI orchestrator: GitHub Actions, GitLab CI, Jenkins, or Azure Pipelines with runners that can run toolchains and (optionally) hardware-in-the-loop (HIL).
Artifact store: S3/MinIO or Nexus for build artifacts, traces, and timing reports.
Gate/Policy engine: fails the pipeline or blocks merges when WCET > budget or when regression > threshold.

Example: GitHub Actions workflow (practical)

Below is a condensed, practical GitHub Actions YAML pattern that demonstrates the flow. This is an actionable starting point — adapt paths, tool versions and hardware runners to your environment.

# .github/workflows/timing-ci.yml
name: CI - Build, Test, Timing

on:
  pull_request:
    branches: [ main ]

jobs:
  build-and-test:
    runs-on: ubuntu-22.04
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Docker toolchain
        run: docker pull myregistry/embedded-toolchain:2026-01

      - name: Build firmware
        run: |
          docker run --rm -v ${{ github.workspace }}:/src myregistry/embedded-toolchain:2026-01 \
            /bin/bash -lc "cd /src && make clean && make all"

      - name: Run VectorCAST tests (headless)
        run: |
          docker run --rm -v ${{ github.workspace }}:/src -v /tmp/artifacts:/artifacts \
            vectorcast/cli:2026 /bin/bash -lc "cd /src/tests && vectorcast run --batch --output /artifacts/vcast_results"

      - name: Collect artifact
        uses: actions/upload-artifact@v4
        with:
          name: vcast-results
          path: /tmp/artifacts/vcast_results

  wcet-analysis:
    runs-on: ubuntu-22.04
    needs: build-and-test
    steps:
      - name: Download vcast results
        uses: actions/download-artifact@v4
        with:
          name: vcast-results
          path: ./vcast

      - name: Run RocqStat WCET analysis
        env:
          ROCQSTAT_MODEL: soc-timing-model-v1.2.json
          ROCQSTAT_TOLERANCE: 0.03
        run: |
          docker run --rm -v ${{ github.workspace }}:/src -v $(pwd)/vcast:/vcast \
            rocqstat/cli:2026 /bin/bash -lc "rocqstat analyze --binary /src/build/myapp.elf --traces /vcast/traces --model /models/${ROCQSTAT_MODEL} --output /vcast/wcet_report.json"

      - name: Publish report
        uses: actions/upload-artifact@v4
        with:
          name: wcet-report
          path: ./vcast/wcet_report.json

Interpreting results: gating and regression rules

To make WCET checks actionable, define clear rules. Here are practical patterns used by teams shipping safety-critical embedded software:

Absolute budget gate: fail if WCET > allocated timing budget for the function/task.
Regression threshold: fail if WCET increases by more than X% relative to baseline (typical X = 2–5%).
Statistical verification: if analysis has non-determinism or uses probabilistic bounds, enforce confidence levels (e.g., 95% upper-bound).
Allow-list for known changes: skip gating for intentional algorithmic changes if developer provides justification and updated budget.

Implement gating in CI by comparing the generated WCET report (JSON or XML) against a saved baseline artifact. For traceability, store the baseline WCET per PR and link it to the commit used for certification evidence.

Example gating snippet (pseudo-code)

# Pseudo-check in CI
baseline = load('baseline/wcet.json')
current = load('vcast/wcet_report.json')
if current.max_execution_time > baseline.budget:
  fail('WCET exceeds budget')
if (current.max_execution_time / baseline.max_execution_time) - 1 > 0.03:
  fail('WCET regression > 3%')

Trace-driven analysis: make estimates tighter and evidence stronger

RocqStat's effectiveness improves when you feed it concrete execution paths or traces from VectorCAST. This lets the WCET engine focus on realistic paths exercised by tests rather than all syntactic control-flow combinations, producing evidence-based WCET results for certification.

Best practices:

Design VectorCAST tests to maximize realistic path coverage for timing-critical tasks (not just statement coverage).
Use test vectors derived from system-level scenarios (drive cycles, HIL cases) where possible.
Keep trace artifacts compact (path IDs and counters) to speed CI runs.

Hardware-in-the-loop vs. host-only CI runs

Timing is inherently platform-dependent. There are two practical CI flavors:

Host/QEMU analysis with platform models — fastest: run on CI runners using RocqStat's platform timing models to estimate WCET. Good for rapid feedback and regression detection.
HIL-based validation — slower: schedule nightly or gated runs on HIL rigs to capture real execution traces and validate the estimates. Required for final acceptance in many certifications.

Combine both: use model-based RocqStat analysis in PRs for quick gating and HIL validation for release branches or milestone builds.

Dealing with multicore, caches, and interference

Multicore SoCs complicate WCET. Use these techniques:

Isolation: run timing-critical tasks on a dedicated core in CI/HIL to avoid best-effort interference.
Interference modeling: include shared resource models (noC, DRAM contention) in RocqStat timing models if supported, or conservatively bound interference in the budget.
Partitioning: demonstrate temporal partitioning policies (e.g., time-triggered scheduling) and verify execution windows in CI.

Reproducibility, toolchain pinning, and traceability

To be credible for certification, CI timing runs must be reproducible and traceable:

Pin VectorCAST, RocqStat, compiler, and timing model versions in CI (Docker images or packages).
Record the exact binary, tool versions, and timing model used with each WCET report.
Store artifacts (binary, trace, wcet_report) in an immutable artifact repository with retention policy aligned to certification needs.

Integrating WCET evidence with certification artifacts

Generate human- and machine-readable WCET evidence:

Per-function and per-task WCET numbers (JSON/XML)
Trace-to-path mappings showing which tests exercised the worst-case path
Tool logs and timing model versions for reproducibility

Attach these artifacts to your work items or release packages. For ASIL D processes, include a short summary in your safety case showing how CI catches timing regressions early and how final HIL runs validate timing budgets.

Operational tips and pitfalls

Tip: Fast feedback, thorough final checks

Use model-based WCET runs in PRs for immediate feedback. Run deep, HIL-backed timing validation on release candidates and nightly jobs.

Pitfall: Treating WCET as a single number

WCET depends on platform model, compiler options, and configuration. Maintain a matrix of WCET budgets per configuration and ensure CI selects the appropriate model based on build flags.

Tip: Keep trace payload small and meaningful

Full execution traces are large. Use path summaries and counters where possible to reduce CI storage and improve analysis time.

Pitfall: Ignoring timing model drift

SoC microcode updates or compiler changes can change timing. Track timing model versions and re-run full WCET baselines when toolchain or SoC firmware changes occur.

Sample Jenkins pipeline snippet (Declarative) for gating

pipeline {
  agent any
  stages {
    stage('Checkout') { steps { checkout scm } }
    stage('Build') { steps { sh 'make all' } }
    stage('VectorCAST') { steps { sh 'vectorcast run --batch --output artifacts/vcast' } }
    stage('WCET') {
      steps {
        sh 'rocqstat analyze --binary build/myapp.elf --traces artifacts/vcast/traces --model models/soc.json --output artifacts/wcet.json'
        sh 'python tools/check_wcet.py artifacts/wcet.json baseline/wcet_baseline.json'
      }
    }
  }
}

Metrics to track and dashboarding

Expose WCET metrics to engineers and managers:

Average and max WCET per task over time
Number of PRs failing WCET gates
Time-to-fix for timing regressions
Coverage of timing-critical paths by VectorCAST tests

Feed JSON WCET reports into your observability stack (Prometheus + Grafana, Elastic) for trend alerts and root-cause correlation with code changes.

Case example: Detecting a hidden regression in a map lookup routine

Scenario: A refactor in a frequently-used lookup added a linear-search fallback in rare branches. Unit tests passed, but CI timing analysis detected a 9% WCET increase in the ECU task. The ROCQSTAT report pointed to a code path exercised only by a specific VectorCAST scenario. Engineers fixed the fallback and the PR passed the WCET gate — saving a costly late-stage rework and preserving the timing budget for that function.

Future trends and what to watch in 2026+

Deeper toolchain integration: Vector's integration of RocqStat into VectorCAST will reduce friction in data exchange (CFGs, traces) and simplify CI scripting.
Standardized timing evidence formats: expect industry moves toward machine-readable timing evidence formats for safety submissions.
Cloud-hosted timing analysis: secure cloud offerings for heavy-weight WCET computations that need more CPU and memory.
AI-assisted anomaly triage: tooling will help prioritize timing regressions by likely impact and root-change heuristics.

Actionable checklist to get started this sprint

Pin VectorCAST and RocqStat versions and create Docker images for CI.
Identify top 10 timing-critical tasks and budgets from the system spec.
Enable VectorCAST test generation for those components and add trace export.
Add a CI stage to run RocqStat against PR builds and publish a JSON WCET report.
Implement a simple gating script: fail on absolute budget breach and >3% regression.
Schedule nightly HIL runs that validate PR findings on real hardware.

Final thoughts

Embedding timing analysis into CI is no longer optional for automotive and safety-critical embedded projects in 2026. The Vector + RocqStat combination gives teams a practical path to automate WCET verification as part of everyday development. With the patterns in this article — trace-driven analysis, gated CI checks, reproducible tooling, and HIL validation — you can catch timing regressions earlier, reduce certification risk, and speed delivery.

Call to action

Start small: add a model-based RocqStat stage to your next PR build and block merges on clear timing budgets. If you want a hands-on demo or example repo adapting these patterns to GitLab or Jenkins, request our sample pipelines and Docker images at devtools.cloud — we’ll share reproducible templates and a checklist to integrate VectorCAST and RocqStat into your CI safely and quickly.

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.