Timing Analysis and WCET in Continuous Integration: Automating VectorCAST + RocqStat

Stop shipping timing surprises: integrate RocqStat WCET into VectorCAST CI

Late builds that pass functional tests but fail timing on hardware are costly — missed deadlines, regressions found in integration, and last-minute rework. In 2026, with Vector Informatik's acquisition of StatInf's RocqStat technology and its planned integration into VectorCAST, it’s practical and urgent to automate worst-case execution time (WCET) and timing analysis inside embedded CI pipelines. This guide gives you a hands-on, production-ready approach to run RocqStat timing analysis in VectorCAST-driven CI, detect regressions automatically, and alert the right teams before integration testing or HIL.

Why timing analysis in CI matters now (2026)

Software-defined vehicles, distributed ECUs, and mixed-criticality architectures mean timing is as critical as functional correctness. Regulators and industry bodies (ISO 26262, SOTIF) increasingly expect traceable evidence that timing constraints are met. Vector’s January 2026 acquisition of RocqStat unified statistical timing analysis and WCET estimation with code-testing tools, making end-to-end automation feasible for teams that already use VectorCAST:

Vector will integrate RocqStat into its VectorCAST toolchain to unify timing analysis and software verification.

In short: if you run VectorCAST for unit/integration tests, you can — and should — make timing analysis part of the same CI pipelines.

What this tutorial covers

• Design patterns for embedding RocqStat WCET runs into VectorCAST CI pipelines
• Sample CI configurations for GitLab CI, GitHub Actions, and Jenkins
• Automation strategies: baseline collection, regression detection, and alerting
• Containerized and Kubernetes-native execution examples
• Best practices, troubleshooting, and future-proofing

High-level architecture

At a glance, the integration pattern is simple:

1. Build and instrument the binary using your VectorCAST project or cross-toolchain.
2. Run functional tests (VectorCAST) to gather realistic execution traces if you use measurement-based WCET estimation.
3. Run RocqStat analysis (statistical WCET or hybrid) against traces or model profiles.
4. Publish RocqStat results (JSON/CSV/HTML) as CI artifacts, and evaluate against baselines.
5. Fail the job or create alerts on statistically significant regressions.

Pipeline triggers and cadence — what to run when

Not all commits need full WCET analysis. Use a tiered strategy:

• Fast checks on pull requests: instrumented unit tests + lightweight RocqStat quick-mode to catch obvious regressions (minutes).
• Merge / main builds: full RocqStat statistical run with sufficient samples and validation (hours depending on test coverage).
• Nightly / weekly: exhaustive measurement campaigns including HW-in-the-loop (HIL) and full statistical recomputation to detect slow trends.
• Pre-release: deterministic runs against the release hardware configuration and baseline comparisons for traceability (required for compliance).

Sample CI: GitLab CI pipeline snippet

Below is a compact GitLab CI job that runs VectorCAST build, then a RocqStat analysis container, and posts a regression status to GitLab. Adapt for your runner environment and license setup.

stages:
  - build
  - test
  - wcet

build:
  stage: build
  image: registry.example.com/toolchains/gcc-arm:2025.12
  script:
    - make clean all
    - docker run --rm -v $CI_PROJECT_DIR:/work -e VC_LICENSE=... vectorcast/vectorcast-cli:2026.1 \
        /work/project.vcast --build
  artifacts:
    paths:
      - build/output

unit_test:
  stage: test
  image: registry.example.com/vectorcast:2026.1
  script:
    - docker run --rm -v $CI_PROJECT_DIR:/work vectorcast/vectorcast-cli:2026.1 \
        /work/project.vcast --run-unit-tests --export-traces /work/traces
  artifacts:
    paths:
      - traces/

wcet_analysis:
  stage: wcet
  image: registry.example.com/rocqstat:2026.1
  script:
    - docker run --rm -v $CI_PROJECT_DIR:/work rocqstat/rocqstat-cli:2026.1 \
        --input /work/traces --output /work/wcet-results --mode statistical --samples 1000
    - python ci/parse_rocqstat.py --results /work/wcet-results --baseline /cached/baseline.json
  artifacts:
    paths:
      - wcet-results/
  when: on_success

Key points

• Use container images and local testing platforms that bundle VectorCAST CLI and RocqStat to ensure reproducibility.
• Maintain a cached baseline artifact in a protected branch or object store.
• Adjust --samples according to required statistical confidence.

Sample CI: GitHub Actions workflow (quick-mode)

name: CI with RocqStat
on:
  pull_request:
    branches: [ main ]

jobs:
  build-and-run:
    runs-on: ubuntu-22.04
    container: vectorcast/vectorcast-cli:2026.1
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: make all
      - name: Run unit tests and export traces
        run: |
          ./vectorcast-cli --project project.vcast --run-unit-tests --export-traces traces
      - name: Run RocqStat quick run
        uses: docker://rocqstat/rocqstat-cli:2026.1
        with:
          args: --input traces --output wcet-results --mode quick --samples 200
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: wcet-results
          path: wcet-results/

Jenkins pipeline fragment (Declarative)

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'make all'
      }
    }
    stage('Unit Tests') {
      steps {
        sh './vectorcast-cli --project project.vcast --run-unit-tests --export-traces traces'
        archiveArtifacts artifacts: 'traces/**'
      }
    }
    stage('WCET Analysis') {
      steps {
        container('rocqstat:2026.1') {
          sh 'rocqstat --input traces --output wcet-results --mode statistical --samples 1000'
          sh 'python3 ci/parse_rocqstat.py --results wcet-results --baseline /var/jenkins_home/baseline.json'
        }
      }
    }
  }
}

Detecting regressions: baseline strategy and thresholds

Simply comparing a single WCET point to a threshold is brittle. Use a hybrid approach:

• Baseline window: store the last N full WCET analyses (N >= 5) with timestamps and tool versions.
• Statistical comparison: compute median and 95th percentile of the baseline samples for each task and use confidence intervals to detect significant shifts.
• Delta thresholds: set absolute and relative thresholds (e.g., absolute +1ms or +5% relative), chosen per critical task.
• Trend detection: run a linear regression on baseline values; allow small drifts but fail on sudden jumps beyond confidence limits.

RocqStat outputs detailed distributions and confidence intervals; parse JSON to extract the tail estimates (e.g., 1e-6 exceedance) and compare them against your baseline model. For reproducibility and artifact handling patterns that avoid brittle client-side caches, see guidance on server-side state and trace provenance.

Example: simple regression checker (Python outline)

#!/usr/bin/env python3
import json, sys
from statistics import median

def load(path):
    with open(path) as f:
        return json.load(f)

results = load(sys.argv[1])  # rocqstat output
baseline = load(sys.argv[2])

alerts = []
for task, stats in results['tasks'].items():
    new_wcet = stats['p_tail']
    baseline_vals = [b['tasks'][task]['p_tail'] for b in baseline if task in b['tasks']]
    if not baseline_vals:
        continue
    base_med = median(baseline_vals)
    rel = (new_wcet - base_med) / base_med
    if new_wcet - base_med > 0.001 and rel > 0.05:
        alerts.append((task, base_med, new_wcet, rel))

if alerts:
    for a in alerts:
        print('REGRESSION', a)
    sys.exit(2)
else:
    print('OK')
    sys.exit(0)

Alerting and feedback loops

Pick a clear feedback mechanism so developers react quickly:

• CI status checks: fail PR checks and add a descriptive failure message linking to the WCET artifact HTML report.
• Issue creation: create a ticket (Jira/GitHub issue) with stack traces, diffs, and the RocqStat report if a critical regression is found.
• Slack / Teams: post a short summary and link to the artifact. Use channels dedicated to release-critical failures.
• On-call / PagerDuty: for emergency regressions that block releases, escalate automatically.

Kubernetes-native execution and scaling

For larger measurement campaigns and nightly runs, run RocqStat jobs in Kubernetes. Below is an example Job manifest that runs a RocqStat container and uploads artifacts to an S3-compatible store. For teams planning edge/hybrid execution and telemetry, consider patterns used in micro-event resilience and edge telemetry deployments.

apiVersion: batch/v1
kind: Job
metadata:
  name: rocqstat-wcet-job
spec:
  template:
    spec:
      containers:
      - name: rocqstat
        image: rocqstat/rocqstat-cli:2026.1
        env:
        - name: S3_ENDPOINT
          value: https://s3.example.com
        - name: S3_BUCKET
          value: wcet-results
        volumeMounts:
        - name: workdir
          mountPath: /work
        command: ["/bin/sh","-c"]
        args:
          - |
            rocqstat --input /work/traces --output /work/output --mode statistical --samples 2000
            && aws --endpoint-url $S3_ENDPOINT s3 cp /work/output s3://$S3_BUCKET/$JOB_NAME/ --recursive
      restartPolicy: Never
      volumes:
      - name: workdir
        persistentVolumeClaim:
          claimName: rocqstat-pvc
  backoffLimit: 2

Reproducibility and licenses

Two operational details are critical:

• Tool versions: lock VectorCAST and RocqStat versions in pipeline images. Pack licensing checks into an authentication step (license server or token) and fail fast if license is unavailable. Use local testing platforms and hosted-tunnel tooling to validate runners against known images before full runs.
• Hardware influence: measurement-based WCET should be done on representative hardware or with cycle-accurate simulators. If you run on cloud/COTS runners, treat results as relative until validated on target hardware. For small-target hardware prototypes (including Raspberry Pi class targets), keep a hardware validation plan that mirrors the target profile.

Case study: small ECU task integrated into CI

Example: a braking controller task 'brake_ctrl' shows a 7% increase in statistical WCET after a change in a lookup table optimization. Walkthrough:

1. Developer opens PR. CI runs quick RocqStat with 200 samples — no significant change detected.
2. Merge to main triggers full RocqStat run with 2000 samples. The regression checker flags 'brake_ctrl' with a new p_tail 1.27ms vs baseline 1.19ms (6.7% increase).
3. CI fails the merge check, posts details to Slack, and opens a ticket with attached RocqStat HTML report and the delta times for review.
4. Developer reverts the LUT change and runs local RocqStat; regression disappears. The fix is committed and the main pipeline passes.

Lessons: run full statistical campaigns on main/merge, keep quick PR checks to short-circuit obvious issues, and automate issue creation to minimize time-to-detect.

Troubleshooting common pitfalls

• Noisy measurements: isolate runs to dedicated CI nodes or use the VectorCAST instrumentation mode that reduces jitter; prefer hardware runs when possible.
• License failures: preflight license check step; provide clear retry guidance for job runners.
• False positives: tune thresholds and use statistical tests rather than single-sample checks.
• Large run times: split analyses by module and parallelize; run quick-mode for PRs and full mode on scheduled builds.

Best practices checklist

• Containerize VectorCAST + RocqStat with fixed versions and store images in a private registry.
• Collect and version baselines; include tool version, hardware profile, and dataset.
• Use statistical comparisons and allow controlled drift windows.
• Fail CI only for meaningful regressions; create non-blocking alerts for noise you want to triage later.
• Archive reports and link them to release artifacts for certification evidence; keep trace provenance and server-side artifact practices in mind.

2026 trends and what to watch next

Two trends are accelerating in early 2026:

• Toolchain consolidation: Vector's acquisition of RocqStat signals tighter integration between testing and timing analysis — expect native VectorCAST plugins that simplify trace export and result ingestion. See consolidation case studies for guidance on the ROI of tighter stacks.
• Cloud and edge convergence: more teams will run reproducible timing campaigns in cloud-like on-prem Kubernetes clusters with access to HIL farm connectors. Plan for mixed execution (simulator + HIL) and keep provenance metadata.

Also watch for standardized WCET CI patterns in automotive toolchains and growing expectations from OEMs for CI evidence in supplier deliveries.

Actionable takeaways

• Start small: add a RocqStat quick run to PRs to catch the lowest-hanging regressions.
• Automate baselines: store and version baseline runs and use statistical checks to avoid false alarms.
• Containerize everything: ensure deterministic tool versions and easy developer reproduction; validate images on local testing platforms before wide rollout.
• Escalate cleanly: wire alerts into your existing triage flow with clear links to RocqStat artifacts.
• Plan for hardware: validate cloud runs on target hardware before release — measurement-based WCET without representative hardware is provisional.

Final notes and call-to-action

Integrating RocqStat WCET analysis into VectorCAST-driven CI is no longer optional for teams building safety-critical automotive software — it's a practical necessity for traceability, early regression detection, and predictable releases. Start with quick PR checks, expand to nightly full statistical campaigns, and automate regression detection and alerts to minimize late-stage surprises.

If you want a jump-start: container images, parser scripts, and sample GitLab/GitHub/Jenkins pipelines are available in our companion repo (example: qubit.host/rocqstat-ci). Try the quick-mode PR integration in your next sprint and set a goal: reduce timing regressions found in HIL by 80% within three months.

Ready to stop timing surprises? Get in touch for a workshop to adapt these patterns to your VectorCAST + RocqStat setup, or download our CI starter pack and run the first automated WCET check in under an hour.

Related Reading

• Critical Ops: Observability, Zero‑Downtime Telemetry and Release Discipline
• Review: Hosted Tunnels and Local Testing Platforms for Smooth Onsite Tech Demos (2026)
• Why Server-Side State Wins in 2026: Cookies, Post‑Quantum TLS and Cache‑First PWAs Reframing the Web
• Advanced Tactics for Micro‑Event Resilience in 2026: Edge Telemetry, Hybrid Trust, and Fast‑Turnaround Ops
• Case Study: How a Small Firm Cut Intake Latency and Improved Evidence Capture (2026)
• Visualizing 'Comeback' Metrics: Data Dashboard of Political Resilience
• Budget vs. Built-to-Last: Cost Comparison of Manufactured Homes and Traditional Alaska Cabins
• How Smart Lamps Can Improve Your Watch Unboxing Videos
• Sticker Packs for Graphic Novel Fans: Creating Assets That Travel Across Media
• Internships in sports streaming and broadcasting: how to get noticed