embeddedtestingCI/CD

Integrating RocqStat WCET Analysis into Your CI Pipeline for Safety‑Critical Software

UUnknown

2026-01-30

10 min read

Hands-on guide to add RocqStat WCET checks into VectorCAST CI—catch timing regressions early, set gates, and produce certification-ready reports.

Catch WCET regressions before release: add timing analysis to CI

Hook: You already run unit tests and static checks in CI — but timing regressions slip through code review, causing late integration failures, missed deadlines, or worse: field safety incidents. In 2026, with Vector's acquisition of RocqStat and the push toward integrated timing-aware toolchains, teams can and should treat WCET (worst-case execution time) as a first-class CI artifact. This guide shows how to integrate RocqStat WCET analysis with VectorCAST in CI (GitHub Actions, Jenkins, GitLab CI) so your pipeline fails fast on timing regressions, not in validation labs.

Why timing analysis matters in CI — 2026 context

Late 2025 and early 2026 saw two clear trends: (1) increased regulation and supplier scrutiny on timing determinism in software-defined vehicles and other safety-critical domains; (2) consolidation of timing-analysis tech into broader verification suites. Vector Informatik's January 2026 acquisition of StatInf's RocqStat underlines this shift. Vector said it plans to integrate RocqStat into the VectorCAST toolchain to create a unified environment for timing analysis and verification (Automotive World, Jan 16, 2026).

As teams adopt more complex mixed-critical systems and edge compute, intermittent timing regressions from compiler changes, refactors, or new platform drivers are common. Adding WCET checks to CI brings timing observability forward in the development loop, reduces expensive late fixes, and helps maintain certification traceability for ISO 26262, DO-178C, and IEC 61508 projects.

What RocqStat + VectorCAST integration enables

Unified verification workflow: unit and integration tests (VectorCAST) plus static and measurement-assisted WCET estimates (RocqStat) in a single pipeline.
Automated regression detection: pipeline gates on WCET deltas (absolute or %), with history and baselines stored per branch or PR.
Certification evidence: traceability from tests to timing analysis reports, helping produce artifacts auditors expect.

High-level CI architecture

At a high level, your CI pipeline should add a timing-analysis stage after tests and before packaging:

  +-----------+     +-----------+    +-----------+    +------------+
  | Build/bin | --> | Unit Test | -> | WCET Run  | -> | Gating &   |
  | (Vector)  |     | (Vector)  |    | (RocqStat)|    | Alerts/FB  |
  +-----------+     +-----------+    +-----------+    +------------+

Key flows:

VectorCAST builds tests and runs functional coverage. Export test traces (execution logs, instrumentation) that RocqStat can consume.
RocqStat produces WCET estimates per function, path, or test-case. Export in machine-readable format (XML/JSON).
CI parses results, compares to a stored baseline, and applies policy: warn, fail, or annotate PR.

Prerequisites and practical setup

Software and licensing

VectorCAST project with unit/integration tests configured.
RocqStat (StatInf) installed or available via Vector's integrated toolchain. You can run RocqStat on a build agent/container.
CI server (GitHub Actions, Jenkins, GitLab) with agents that can run build and timing tools. Consider using dedicated agents for deterministic measurements or container images for static WCET analysis.

Hardware vs. static analysis

RocqStat supports both static analysis and measurement-assisted WCET (MA-WCET). Decide what your pipeline will run:

Static/Subsystem analysis: fast, runs on CI agents, good for early detection. No hardware required.
Measurement-assisted or hardware-in-the-loop: more accurate, requires target hardware or HIL racks. Typically reserved for nightly/full verification pipelines.

Step-by-step: Add RocqStat WCET checks to CI

1) Build artifacts and export test traces

Ensure VectorCAST produces the binaries and any execution traces or control-flow graphs RocqStat needs. Export formats commonly used are:

ELF/microcontroller binary
Control-flow graph (CFG) or compiled object files
Execution traces/logs (for MA-WCET)

2) Add a timed-analysis stage in CI

Insert a stage that runs RocqStat on the artifacts. For static WCET this can run in a container; for MA-WCET you may need a reserved agent that connects to hardware.

  # example (bash) - simplified
  set -e
  # 1. run rocqstat analysis
  rocqstat analyze --project build/my_project.rocq --output reports/rocqstat.json
  # 2. produce summary
  rocqstat summarize --input reports/rocqstat.json > reports/wcet-summary.json

Note: the exact CLI will depend on your RocqStat/VectorCAST integration. The important outputs are machine-readable summaries and per-function WCET values.

3) Store baselines and maintain history

Keep a baseline WCET manifest per branch (or per release). This can be a JSON file in an artifacts bucket, or a file in an artifacts repository. Baseline should include:

Function identifier (name + signature + compilation hash)
Baseline WCET (us or cycles)
Timestamp and CI build id

4) Compare results and apply policy

CI step compares current WCET to baseline. Example policies:

Fail if any function exceeds baseline by > 10% or > 100us (configurable)
Warn on small regressions; require manual triage
For MA-WCET, require reproducibility across N runs before gating

  # pseudo-logic
  for fn in current_wcets:
    base = baseline[fn.name]
    delta = (current - base) / base
    if delta > 0.10 and (current - base) > 100us:
      exit 1  # fail CI
  done

5) Report results and alert

Publish RocqStat outputs to:

HTML or PDF report attached to CI run
Machine-readable JSON for dashboards
Slack/GitHub PR comment with summarized regressions and links

  # example: post PR comment with jq
  jq -r '.regressions[] | "Function: \\(.name) base=\\(.base) now=\\(.now) "' reports/wcet-summary.json | gh pr comment --body -

CI examples: GitHub Actions and Jenkins

GitHub Actions example

  name: CI
  on: [push, pull_request]
  jobs:
    build-and-test:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v4
        - name: Build VectorCAST project
          run: ./scripts/build_vectorcast.sh
        - name: Run VectorCAST unit tests
          run: ./scripts/run_vectorcast.sh --export-trace traces/output.trace
        - name: Run RocqStat WCET
          run: |
            docker run --rm -v ${{ github.workspace }}:/work rocqstat:latest \
              /bin/sh -c "rocqstat analyze --trace /work/traces/output.trace --out /work/reports/rocqstat.json"
        - name: Compare WCET baseline
          run: ./ci/check_wcet_regressions.sh reports/rocqstat.json baseline/wcet-baseline.json

Jenkins pipeline snippet

  pipeline {
    agent any
    stages {
      stage('Build') { steps { sh './scripts/build_vectorcast.sh' } }
      stage('Unit Test') { steps { sh './scripts/run_vectorcast.sh --export-trace traces/out.trace' } }
      stage('WCET Analysis') {
        steps {
          sh 'rocqstat analyze --trace traces/out.trace --out reports/rocq.json'
        }
      }
      stage('WCET Gate') {
        steps {
          sh './ci/check_wcet_regressions.sh reports/rocq.json baseline/wcet-baseline.json'
        }
      }
    }
  }

Dealing with noise and flakiness

Timing analysis can be noisy. Use these techniques to reduce false positives:

Hash artifacts: baseline per compilation hash to avoid irrelevant deltas when build options change.
Multiple runs: for MA-WCET, run N times and use a high percentile (e.g., 99th) or take the maximum across runs.
Stable baseline promotion: only update baseline after a green full-verification run or via an approved PR.
Ignore low-impact diffs: small microsecond deltas for non-critical paths can be recorded but not gated.

Observability: dashboards, metrics, and alerts

Make timing visible to developers and SREs:

Export RocqStat JSON to Prometheus or an ELK stack (via a small exporter) so you can chart trends.
Create per-module heatmaps showing functions with regressed WCET across commits.
Integrate alerts into Slack/MS Teams and link to the failing PR with a short diff.

  # Example: convert RocqStat JSON to Prometheus metrics (pseudo)
  {
    "metrics": [
      {"name": "wcet_ns", "labels": {"fn": "foo"}, "value": 2300}
    ]
  }

Traceability and certification artifacts

For ISO 26262/DO-178C compliance, keep these artifacts per release:

RocqStat raw outputs and summaries
VectorCAST test cases and coverage reports
Baseline manifests and approval history
Change logs linking commits to timing deltas and risk assessments

Include automated links between test cases and timing analysis results in your ALM (JIRA) for traceability. Keep compliance and audit controls in mind — treat these artifacts as part of your release evidence and security posture (see best practices on patch and change management when certifying systems).

Scaling and CI performance

WCET analysis can be compute-intensive. To scale:

Run static analyses in parallel across modules.
Use caching: skip analysis for files with unchanged compilation hashes.
Run full MA-WCET nightly on dedicated HIL labs while keeping fast static checks per PR.

Case study: catching a regression in a braking ECU module

Scenario: A refactor introduced a logger that added a conditional path executed rarely. Unit tests passed; integration tests passed in lab. On the next run, RocqStat in CI flagged a 22% WCET increase for brake_control_loop(). The PR failed the WCET gate. The developer reverted the logger change, re-ran tests and RocqStat locally, and created a focused optimization (guard the logging path). The PR then passed. Without WCET checks in CI this would have been caught much later during HIL regression or in-field, where latency could have been safety critical.

Best practices and expert tips

Treat WCET as code: version baselines and require PRs to justify any accepted increases.
Automate triage: annotate regressions with hot paths and suggested fixes (inline assembly/loop bounds warnings).
Use combined analysis: static for speed, MA-WCET for accuracy. Flag high-risk deltas for hardware verification.
Keep CI feedback actionable: short failure messages, per-function deltas, and links to the failing test run and trace.

Costs, licensing, and vendor lock-in considerations

Vector's acquisition of RocqStat simplifies integration into VectorCAST, but consider:

License footprints for CI agents — ensure license seats for dedicated analysis runners.
Containerizing RocqStat reduces environment drift and simplifies ephemeral CI agents.
Keep exports and baselines in open formats (JSON/XML) so you can migrate analysis data if vendor strategies change.

2026 trends and what to watch

Greater integration of timing analysis into unified verification suites (Vector + RocqStat is a clear example).
AI-assisted regression triage: emerging tools use ML to prioritize timing deltas by likely root cause and risk.
Edge/automotive networks demand tighter end-to-end latency assurance — WCET in CI will expand to E2E multi-node analyses.
Standard bodies increasingly expect continuous evidence of timing regression controls during development cycles.

In January 2026 Vector said integrating RocqStat would "create a unified environment for timing analysis, WCET estimation, software testing and verification workflows" — an explicit push to operationalize timing safety in development pipelines (Automotive World, Jan 16, 2026).

Actionable checklist to implement today

Identify critical functions and timing budgets in your system — start with top 10 high-risk paths.
Enable VectorCAST test exports that RocqStat can consume.
Provision a CI job to run RocqStat static analysis on PRs and store JSON outputs.
Create a baseline manifest and gating policy (fail/warn thresholds).
Configure alerts (Slack/PR comments) and dashboards to surface regressions.
Plan nightly MA-WCET runs on HIL for high-accuracy verification and baseline promotion.

Final recommendations

Making timing analysis part of CI moves timing left in your lifecycle. With Vector's integration of RocqStat into VectorCAST, teams have a clearer path to embed WCET checks into developer workflows. Start small (static checks per PR), enforce baselines and policies, and escalate to MA-WCET on hardware for release candidates. Keep outputs machine-readable for dashboards and auditors. And treat WCET regressions like test failures — fast, visible, and actionable.

Next steps & call-to-action

Ready to reduce timing surprises? Start by instrumenting one critical module with VectorCAST, add a RocqStat CI stage as outlined above, and iterate your gating thresholds. If you need a reference implementation, download our CI starter repo (VectorCAST + RocqStat template) and an example GitHub Action that installs a RocqStat runner, exports reports, and posts regressions to PRs. Implement timing gates now so your next release is predictable and certifiable.

Get the starter repo and CI templates → Visit functions.top/resources to grab the examples and a prebuilt GitHub Actions workflow for VectorCAST + RocqStat integration.

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.