Integrating WCET and Timing Analysis into Embedded CI with VectorCAST + RocqStat

Hook: Stop letting timing regressions sneak into safety releases

If you ship embedded software for safety-critical systems, your most urgent CI problem isn’t flaky tests — it’s timing regressions. A single change that increases a task’s worst-case execution time (WCET) can break schedulability and violate functional safety requirements. Yet many engineering teams still treat timing analysis as a late-stage manual step. The result: long verification cycles, fragile release gates, and unexpected rework.

This hands-on tutorial shows how to plug RocqStat timing analysis into an embedded CI/CD pipeline driven by VectorCAST, so you can enforce timing gates, generate actionable WCET reports, and automate safety-critical release rules. The workflow below is practical, repeatable, and designed for teams who need deterministic timing visibility in 2026 and beyond.

Why this matters in 2026 (short context)

Vector Informatik’s January 2026 acquisition of StatInf’s RocqStat brought advanced WCET capabilities closer to mainstream verification workflows by integrating timing analysis into the VectorCAST ecosystem. The result: a more unified environment for functional testing and timing safety that aligns with the increasing demands of automotive, aerospace, and industrial control systems. As Vector said at the time, bringing RocqStat into VectorCAST addresses the rising industry need for rigorous timing verification across software-defined domains (Automotive World, Jan 2026).

“Timing safety is becoming a critical requirement across software-defined industries.” — paraphrase from Vector Informatik (Automotive World, Jan 2026)

What you’ll get (executive summary)

• Concrete CI pipeline examples that run VectorCAST tests and invoke RocqStat analysis.
• Gating rules and policy examples for safety-critical releases (graded by criticality).
• Reporting patterns and artifact structures that integrate with existing test dashboards.
• Advanced tips for HIL, multi-core interference, and reproducible runs in 2026 environments.

Prerequisites and assumptions

• Licensed VectorCAST toolchain installed on CI runners (or an agent with VectorCAST CLI access).
• RocqStat binaries or CLI available on the same CI runners (integration will be automated). Vector’s 2026 roadmap expects RocqStat to be embedded into VectorCAST in medium term; this guide covers the practical hybrid approach used now.
• Access to the target build artifacts (ELF, map files) and trace or profiling data where measurement-based WCET is used.
• CI system (GitLab CI, Jenkins, or GitHub Actions) capable of running containers or dedicated agents with access to target hardware.
• Basic familiarity with scheduling theory, WCET concepts, and the safety standard applicable to your domain (ISO 26262, DO‑178C, IEC 61508).

High-level integration architecture

At a glance, the integrated pipeline has four stages:

1. Build — compile with debug/symbols and deterministic flags.
2. VectorCAST tests — run unit/integration tests and collect coverage/traces.
3. RocqStat analysis — use static and measurement inputs to estimate WCET per function/task.
4. Gating & Reporting — fail or tag the build; publish WCET artifacts and dashboards.

Implementation notes:

• Use containers for consistent toolchain versions (VectorCAST + RocqStat) on CI agents.
• Store and version the build map, ELF, and the RocqStat project files so analyses are reproducible.
• Keep a canonical mapping between test-case IDs in VectorCAST and code locations used by RocqStat.

Step-by-step: Example pipeline (GitLab CI)

The example below shows a practical GitLab CI pipeline that runs VectorCAST tests and then runs RocqStat. You can adapt it to Jenkins or GitHub Actions with equivalent steps.

# .gitlab-ci.yml (excerpt)
stages:
  - build
  - test
  - timing
  - publish

variables:
  VECTORCAST_CLI: "/opt/vectorcast/bin/vcast.exe"
  ROCQSTAT_CLI: "/opt/rocqstat/bin/rocqstat"
  WCET_THRESHOLD_MS: "5.0"   # example system-level budget

build:
  stage: build
  image: registry.example.com/embedded/toolchain:2026.01
  script:
    - make clean all CFLAGS="-g -O2 -fno-exceptions"
    - cp build/app.elf artifacts/
  artifacts:
    paths:
      - artifacts/app.elf

vectorcast_unit_tests:
  stage: test
  image: registry.example.com/vectorcast:2026
  script:
    - ${VECTORCAST_CLI} --import-project project.vcast --build-dir build --run-all
    - ${VECTORCAST_CLI} --export-execution-trace traces/exec-trace.json
  artifacts:
    paths:
      - traces/exec-trace.json
      - vcast-results/*.xml

rocqstat_analysis:
  stage: timing
  image: registry.example.com/rocqstat:2026
  script:
    - ${ROCQSTAT_CLI} analyze --elf artifacts/app.elf --map build/app.map --trace traces/exec-trace.json --output rocq-results/analysis.json
    - python tools/parse_rocq_to_junit.py rocq-results/analysis.json > rocq-results/rocq-junit.xml
    - |
      if python tools/check_gates.py rocq-results/analysis.json --threshold ${WCET_THRESHOLD_MS}; then
        echo "Timing gates passed"
      else
        echo "Timing gates failed"; exit 2
      fi
  artifacts:
    paths:
      - rocq-results/analysis.json
      - rocq-results/rocq-junit.xml

publish_artifacts:
  stage: publish
  script:
    - mkdir -p public/timing
    - cp rocq-results/analysis.json public/timing/
    - cp vcast-results/*.xml public/tests/
  artifacts:
    paths:
      - public/

Key points in this pipeline

• VectorCAST produces execution traces and functional test results; traces are consumed by RocqStat.
• RocqStat runs an analysis that blends static path analysis and measurement inputs to output WCET estimates.
• check_gates.py evaluates WCET numbers against configured thresholds and fails the job if limits are exceeded.
• Artifacts are stored so release engineers can audit and sign-off on WCET reports for safety evidence.

Sample scripts and parse logic (practical)

Below are two small helpers to make gating repeatable. The first converts RocqStat JSON into a JUnit-style XML so CI dashboards can show timing regressions. The second enforces a simple gating rule.

# tools/parse_rocq_to_junit.py (simplified)
import json, sys
from xml.etree.ElementTree import Element, SubElement, tostring

j = json.load(open(sys.argv[1]))
root = Element('testsuites')
for func in j.get('functions', []):
    ts = SubElement(root, 'testsuite', name=func['name'])
    tc = SubElement(ts, 'testcase', name='wcet')
    wcet_ms = func['wcet_ms']
    threshold = func.get('budget_ms', None)
    if threshold and wcet_ms > threshold:
        err = SubElement(tc, 'failure')
        err.text = f"WCET {wcet_ms}ms > budget {threshold}ms"
print(tostring(root).decode())

# tools/check_gates.py (simplified)
import json, sys, argparse

p = argparse.ArgumentParser()
p.add_argument('jsonfile')
p.add_argument('--threshold', type=float, default=None)
args = p.parse_args()

j = json.load(open(args.jsonfile))
max_wcet = max((f['wcet_ms'] for f in j.get('functions', [])), default=0.0)
print(f"Max WCET: {max_wcet}ms")
if args.threshold and max_wcet > args.threshold:
    print('Threshold exceeded')
    sys.exit(1)
else:
    sys.exit(0)

Designing gating rules for safety-critical releases

Gating is policy, not just tooling. Below are pragmatic, tiered policies you can adopt and tune for your project.

Tier 1 — Development (fast feedback)

• Run lightweight RocqStat analysis per commit (incremental): only flag increases > 10% for high-volume branches.
• Warn on regressions, but don’t block merges to feature branches.
• Keep historical WCET trends visible in dashboards so engineers can triage gradually.

Tier 2 — Release Candidate (pre-integration)

• Full RocqStat analysis with measurement inputs and a deterministic environment.
• Hard gates: no function WCET shall exceed its allocated budget; overall task WCET must keep a safety margin (e.g., 20%).
• Any near‑margin (> 80% of budget) results require peer review and an annotated mitigation plan.

Tier 3 — Safety Signoff

• End-to-end timing verification that includes multi-core interference modeling or HIL results.
• Formal documentation: include RocqStat provenance (tool version, input files, seed, environment snapshot) as traceability evidence.
• Sign-offs from responsible engineers, and inclusion of WCET artifacts in the safety case (ISO 26262/DO‑178C evidence).

Reporting: what to store and how to present it

Produce machine-readable artifacts and human-friendly summaries. Typical artifact set:

• RocqStat raw output (JSON/XML) with per-function WCET and analysis metadata.
• JUnit-style XML so CI dashboards show timing failures inline with unit tests.
• CSV of function-level WCET for trend ingestion into time-series systems (Prometheus/Grafana).
• PDF summary with graphs (timing histograms, path annotations) for safety auditors.

Example metrics export lines for Prometheus Pushgateway (from CI job):

# Example pushed by CI job
wcet_max_seconds{function="encoder_task"} 0.032
wcet_mean_seconds{function="encoder_task"} 0.017
wcet_budget_seconds{function="encoder_task"} 0.05

These metrics let you build dashboards that track regressions, show heatmaps of functions approaching budgets, and trigger alerts when thresholds are crossed.

Advanced strategies and caveats (real-world)

1. Combine measurement-based and static analysis

RocqStat is most effective when it combines static path analysis with measurement data from VectorCAST traces or HIL runs. Static analysis finds candidate worst paths; measurements validate that the path is executable and provide observed timing. Use both to reduce pessimism while keeping formal guarantees.

2. Multi-core interference and shared resources

In 2026, multi-core SoCs and shared caches make WCET estimation more complex. Two practical mitigations:

• Run isolation-based tests on CI agents (disable co-scheduled tasks, nix hypervisors) to measure baseline WCET.
• Model shared-resource interference using static analyses where feasible or include worst-case interference bounds from hardware vendors in RocqStat configuration.

3. Reproducibility and tool provenance

For safety audits, record:

• Exact tool versions (VectorCAST, RocqStat, compiler toolchain) and container image digest.
• Input build artefacts (ELF, map files), RocqStat project files, and execution traces.
• CI job logs, seed values, and a snapshot of the testbed (hardware serial, firmware revision).

4. Handling nondeterminism

Reduce noise in measurements by:

• Running tests in controlled environments (disable power management, network traffic).
• Averaging multiple runs and keeping distribution metrics, not just maxima.
• Flagging inconsistent behavior for root-cause analysis instead of immediately failing a release gate.

Operationalizing WCET in observability tooling

Don’t silo timing data. Integrate RocqStat outputs with your observability stack:

• Export per-function WCET metrics to Prometheus/Grafana for trend analysis.
• Correlate performance regressions with code commits via your CI system and annotation tools (e.g., GitHub checks or GitLab merge request comments).
• Create alerts that trigger when a function’s WCET exceeds its moving baseline by a configurable percentage.

Case example: scheduling budget breach detected in CI

Scenario: an optimization in an encoder function reduced average latency but introduced a rare worst-case path that increases WCET by 25%. The VectorCAST unit tests pass, but RocqStat, fed by execution traces, identifies an unexpected increase. CI gating fails the merge and opens a ticket with the RocqStat PDF and JUnit entry attached.

Outcome: The engineer re-runs a targeted VectorCAST test with additional instrumentation, identifies a corner-case loop condition, and introduces a bounded-check to restore WCET within budget. The revised change passes both VectorCAST and RocqStat in CI.

Auditability and compliance (safety evidence)

For ISO 26262/DO‑178C compliance, WCET analysis must be traceable and repeatable. Best practices:

• Embed RocqStat outputs into your safety artifact repository with identifiers that map back to requirements and test cases.
• Use VectorCAST’s test case mapping to show which tests exercise the paths used by RocqStat.
• Keep a snapshot of the CI job and its environment as part of the release record (container digest, job log, artifacts).

2026 trends and future-proofing your workflow

• Tool consolidation: Expect tighter VectorCAST + RocqStat integration through 2026, reducing the friction of hand-offs between test and timing analysis.
• AI-assisted analysis: Newer releases increasingly use ML to prioritize candidate worst-case paths; use these features to speed triage but validate decisions with deterministic analysis for safety cases.
• Virtualized HIL: Simulation accuracy is improving — you can run representative timing scenarios in CI for early detection, but keep physical HIL for final signoff.
• Supply chain visibility: With software-defined vehicles and devices, auditors expect end-to-end provenance that includes third-party timing assumptions — capture vendor-supplied interference bounds.

Checklist: Quick pragmatic starter

• Install compatible VectorCAST and RocqStat versions in CI runners; use container images for repeatability.
• Make VectorCAST produce execution traces as part of normal test runs.
• Run RocqStat analysis automatically, produce JSON outputs and JUnit XML for CI dashboards.
• Implement gating rules tuned to branch type (dev vs release) and criticality levels (ASIL/RTCA).
• Record tool versions and environment snapshots alongside the WCET artifacts.
• Visualize WCET trends in Grafana and configure alerts for regressions.

Closing: practical next steps and call-to-action

Integrating RocqStat timing analysis into your VectorCAST-driven embedded CI pipeline turns timing from a late-stage risk into a first-class CI signal. Start by adding a dedicated RocqStat stage in your CI, produce machine-readable WCET artifacts, and enforce tiered gating rules that match your organization’s safety posture.

If you want a ready-made starter kit, we publish a reference repo with container images, example VectorCAST invocations, RocqStat runner scripts, and CI templates for GitLab/Jenkins/GitHub Actions. Contact midways.cloud to schedule a hands-on workshop where we’ll adapt these templates to your toolchain and safety requirements.

Actionable next step: Clone the reference repo, enable the RocqStat stage in a feature branch, and run two CI cycles: one to baseline WCET, another to introduce a deliberate micro-optimization and observe the gating behavior. Use the results to define your gating thresholds and add WCET metrics to your dashboards.

Need help designing gating rules that map to ASIL or DO‑178C levels? Reach out — we’ll help you build the pipeline, configure RocqStat, and create the evidence pack auditors will accept.

Related Reading

• How Building LEGO Sets Supports Language and Story Skills: Use Zelda Scenes to Boost Literacy
• Emergency Playbook: Response Steps for a Major Platform Security Outage Affecting E-signatures
• Stop Cleaning Up After AI: Automating Quality Checks for Visual Assets
• Classroom Lab: Build a Model of a Buried Plant Trap to Teach Functional Morphology
• Travel Beauty: What to Buy at Convenience Stores When You Forgot Your Routine