embeddedci/cdsafety

Integrating Timing Analysis into Release Gates for Safety-Critical Systems

UUnknown

2026-02-13

9 min read

Add RocqStat and VectorCAST timing checks to your CI as a release gate to prevent late-stage WCET regressions and produce audit-ready evidence.

Hook: Stop late-stage timing failures from derailing releases

Safety-critical embedded teams face a familiar, high-risk pattern: unit tests and functional verification pass, but late in integration or in the field a task misses its deadline. That failure triggers long rework cycles, missed certification milestones and expensive recalls. In 2026 the stakes are higher — regulators and OEMs expect demonstrable timing assurance as part of the release pipeline. This guide shows how to integrate timing analysis (WCET and probabilistic estimates) into automated release gates using RocqStat and VectorCAST so that timing regressions block a release, not a test run.

Why this matters now (2026 trends)

Late 2025 and early 2026 saw significant consolidation in the timing-analysis tooling space. Notably, Vector Informatik acquired the StatInf RocqStat technology and team in January 2026 — a move intended to unify timing analysis and code testing workflows. That consolidation means you can expect tighter integrations between static/measurement-based WCET tooling and code testing environments in the medium term.

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

For DevOps and release engineering teams this trend creates an opportunity: bring timing verification earlier into Continuous Integration and use it as an automated release gate that produces repeatable evidence for safety cases (ISO 26262, DO-178C) and operational reliability.

Goals and constraints for a timing-based release gate

Goal: Automatically reject any merge/build candidate whose task WCET exceeds the certified budget or that introduces unacceptable timing variance.
Constraint: Build-time budgets and test fixtures must be deterministic enough to generate meaningful timing data.
Outcome: Reproducible artifacts (traces, reports, signed WCET numbers) attached to the build for audits and certification.

Timing analysis techniques to include in CI

Mixing methods is best practice — each provides complementary evidence:

Static WCET analysis — conservative, tool-based bounds on execution time. Use to show worst-case syntactic paths.
Measurement-based timing analysis (MBPTA) — statistical analysis of repeated measurements, producing probabilistic bounds. RocqStat has been used for this kind of statistical timing analysis.
Hybrid approaches — use static analysis to bound some paths and MBPTA to refine others.

Practical pipeline architecture

Embed timing checks into CI with three layers:

Build & instrumentation — compile with timing flags, deterministic runtime configuration, and test stubs produced by VectorCAST where applicable.
Execute & collect — run tests on a reproducible runner (QEMU or dedicated hardware), collect cycle counts/traces, and push artifacts.
Analyze & gate — run RocqStat (or VectorCAST-invoked RocqStat) to produce WCET estimates, compare to thresholds, and decide pass/fail.

Key infrastructure components

Deterministic runners: pinned QEMU images or dedicated lab boards using CPU isolation and fixed frequency. For infrastructure patterns that emphasize edge determinism and provenance, see Edge-First Patterns for 2026.
Trace capture: hardware cycle counters, instruction tracing (ETM), or instrumented timers when hardware counters are not available. If you need to spec lab hardware, check recent device roundups and CES 2026 gadget coverage for recommended capture devices: CES 2026 Gadgets.
Artifact storage: persist traces, RocqStat JSON results, VectorCAST test reports to the CI artifact store for audit. Architect storage with cost and retention strategy in mind — a useful primer is A CTO’s Guide to Storage Costs.
License manager: VectorCAST/RocqStat licensing often requires a manager; include license checks early in the pipeline. Monitor platform and tooling market changes that can affect licensing terms: Security & Marketplace News: Q1 2026.

Designing the gate policy

A gate must be actionable and predictable. Use three classes of policies:

Hard fail: WCET > required budget — block the merge. Required for production branches and release tags.
Soft advisory: WCET within X% of budget — create an issue and attach timing report; do not block automatically for feature branches.
Alert only: new tests failing to run or missing artifacts — alert engineering groups to take corrective action.

Common pitfalls and mitigations

Non-deterministic measurements: Use CPU isolation, disable dynamic frequency scaling, and run inside reproducible containers or fixed hardware.
False-positives: Instrumentation overhead can inflate times — subtract instrumentation overhead or use hardware counters when possible.
Toolchain variance: Pin compilers, linker scripts, and optimization levels in CI images.
Slow CI runs: Use staged gates. Run fast static checks on every push; run full MBPTA only on merge requests or nightly builds. Staged gates and hybrid edge workflows are covered in more detail here: Field Guide: Hybrid Edge Workflows for Productivity Tools.

Sample CI pipelines

Below are practical examples you can adapt. Each pipeline assumes a wrapped tool-driver script (scripts/run_timing.sh) that orchestrates the build, test execution, trace collection and calls RocqStat/VectorCAST. The wrapper standardizes outputs to a well-known JSON report (wcet-report.json) and sets exit codes for pass/fail behavior.

1) GitHub Actions (matrix for QEMU and hardware)

# .github/workflows/timing-gate.yml
name: Timing Gate
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  timing-check:
    runs-on: ubuntu-22.04
    strategy:
      matrix:
        runner: [qemu, hw]
    steps:
      - uses: actions/checkout@v4
      - name: Set up toolchain
        run: scripts/setup_toolchain.sh
      - name: Run timing driver
        env:
          ROCQSTAT_LICENSE: ${{ secrets.ROCQSTAT_LICENSE }}
          VECTORCAST_LICENSE: ${{ secrets.VECTORCAST_LICENSE }}
          TIMING_THRESHOLD_US: 1500
        run: |
          chmod +x scripts/run_timing.sh
          scripts/run_timing.sh --runner ${matrix.runner} --out artifacts
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: timing-artifacts-${{ matrix.runner }}
          path: artifacts/
      - name: Evaluate WCET
        if: always()
        run: |
          cat artifacts/wcet-report.json
          node scripts/evaluate_wcet.js artifacts/wcet-report.json $TIMING_THRESHOLD_US

Notes: the evaluate_wcet.js script reads JSON and exits non-zero if WCET > threshold. The run_timing.sh encapsulates VectorCAST test generation and a RocqStat invocation. Normalize outputs so artifact consumers can extract metadata; consider adding automated metadata extraction to your artifact pipeline via DAM/metadata tooling: Automating Metadata Extraction with Gemini and Claude.

2) GitLab CI (fast static then full MBPTA)

# .gitlab-ci.yml
stages:
  - build
  - static-timing
  - mbpta

build:
  stage: build
  image: registry.example.com/embedded/build-image:2026-01
  script:
    - scripts/build.sh
  artifacts:
    paths:
      - build/

static_timing:
  stage: static-timing
  image: registry.example.com/tools/vectorcast:2026
  script:
    - scripts/run_vectorcast_static.sh --out artifacts/static
  artifacts:
    paths:
      - artifacts/static

mbpta:
  stage: mbpta
  image: registry.example.com/tools/rocqstat:2026
  script:
    - scripts/setup_hil_lab.sh
    - scripts/run_mbpta.sh --traces artifacts/static/traces --out artifacts/mbpta
  dependencies:
    - static_timing
  when: manual
  only:
    - master

Notes: MBPTA runs manually or on a schedule because it is expensive. Static timing runs for each merge request to find obvious regressions.

3) Jenkins declarative pipeline (blocking release job)

pipeline {
  agent any
  stages {
    stage('Checkout') {
      steps { checkout scm }
    }
    stage('Build') {
      steps { sh 'scripts/build.sh' }
    }
    stage('VectorCAST Unit Tests') {
      steps { sh 'vectorcast_run_tests --project project.vcast --report reports/vcast.xml' }
    }
    stage('Timing Analysis') {
      steps {
        withCredentials([string(credentialsId: 'rocqstat-lic', variable: 'ROCQ_LIC')]) {
          sh 'scripts/run_timing.sh --runner hw --license $ROCQ_LIC --out artifacts'
        }
      }
    }
    stage('Gate Evaluation') {
      steps {
        script {
          def result = sh(returnStdout: true, script: 'jq .wcet_us artifacts/wcet-report.json').trim()
          if (result.toInteger() > params.WCET_THRESHOLD.toInteger()) {
            error "WCET ${result}us exceeds threshold ${params.WCET_THRESHOLD}us"
          }
        }
      }
    }
  }
}

Notes: Jenkins can integrate with issue trackers and create an incident automatically when a timing gate fails.

What the run_timing.sh wrapper should do

Keep this script small and deterministic. Example responsibilities:

Check and acquire VectorCAST / RocqStat license tokens.
Build binaries with pinned toolchain and reproducible flags (e.g. -fno-omit-frame-pointer for easier tracing).
Run VectorCAST-generated tests on the selected runner (QEMU or hardware) and collect traces.
Invoke RocqStat analysis using the collected traces or instrumentation output.
Produce a normalized JSON: { "task": "T1", "wcet_us": 1234.5, "confidence": 1e-6, "method": "MBPTA", "raw": "artifacts/rocqstat.xml" }.
Exit with code 0 for pass, non-zero for fail. Keep pass/fail logic only in the evaluation step for clarity.

Example evaluate_wcet.js (pseudo)

const fs = require('fs');
const report = JSON.parse(fs.readFileSync(process.argv[2]));
const threshold = Number(process.argv[3]);
const wcet = report.wcet_us;
console.log(`WCET: ${wcet}us, Threshold: ${threshold}us`);
if (wcet > threshold) {
  console.error('TIMING GATE FAILED');
  process.exit(2);
}
console.log('TIMING GATE PASSED');
process.exit(0);

Traceability and artifact hygiene

For safety cases and audits, ensure each timing report includes:

Unique build identifier and VCS commit hash.
Tool and version metadata (VectorCAST version, RocqStat version, compiler, linker, SDK). For automating metadata capture consider integrating with metadata tooling: Automating Metadata Extraction with Gemini and Claude.
Hardware/runner description and deterministic configuration snapshot (CPU freq, isolation flags).
Raw traces and processed results (both human-readable and machine-parsable JSON/XML).

Integration with release management and safety cases

When a release candidate passes functional tests and the timing gate, attach artifacts to the release package. Those artifacts form part of timing evidence in:

ISO 26262: timing constraints used in the safety analysis and evidence of compliance with timing budgets.
DO-178C: objectives concerning execution time measurement and analysis.

Automate the generation of a timing assurance bundle during release: include WCET reports, tool SBOMs, and trace archives. Sign the bundle using your CI signing key to ensure integrity. For cost and retention planning on artifacts and bundles, reference storage cost guidance: A CTO’s Guide to Storage Costs.

Case study vignette (example workflow)

Engineering Team A adopted a staged gate in late 2025. They ran static WCET checks on each PR and scheduled nightly MBPTA runs. After integrating RocqStat into their VectorCAST-driven tests they reduced late-stage timing regressions by 70% over 6 months. The cost was a 20% increase in CI runtime for release branches but a significant reduction in hotfix cycles post-release. They used the following practices:

Pin tool versions and container images.
Keep MBPTA runs to nightly or merge-only to reduce CI load.
Store signed timing bundles with the release artifact repository.

See a separate case-study format for workflows and data-driven outcomes: Case Study: Why Seton Hall and Nebraska Are Outperforming Expectations (structure inspiration for documenting outcomes).

Advanced strategies and future-proofing (2026+)

Expect tighter integration between VectorCAST and RocqStat — plan for these advances:

API-first orchestration: move from wrapper scripts to direct VectorCAST & RocqStat API calls so CI servers can orchestrate finer-grained analyses. Architectural guidance on moving to API-first orchestration and edge patterns is available here: Edge-First Patterns for 2026.
Containerized determinism: vendor-provided container images with signed toolchains and embedded license-handling for reproducible runs in ephemeral CI agents. Field guidance on hybrid edge/container workflows: Hybrid Edge Workflows.
Tighter coverage+timing correlation: combine coverage data from VectorCAST with WCET hotspots from RocqStat to prioritize optimization work.
Supply chain security: collect SBOM and signed tool manifests so timing evidence remains valid across audits. Automating metadata and SBOM collection helps here: Automating Metadata Extraction with Gemini and Claude.

Checklist: What to implement this quarter

Pin compiler and toolchain versions and create CI images. (Consider composable vendor images and manifests: Composable Practices.)
Implement scripts/run_timing.sh and a normalized wcet-report.json output.
Add a short static timing gate on PRs and a full MBPTA gate on merge/nightly.
Store artifacts, include signatures and tool metadata for each run.
Define and document gate thresholds and responsibilities for timing failures.

Final recommendations

Integrating timing analysis into CI as a release gate is both technically feasible and operationally valuable in 2026. Use staged gates to balance CI cost and assurance, standardize outputs for traceability, and automate failure handling so engineers get immediate, actionable diagnostics. With Vector's acquisition of RocqStat, expect smoother workflows between runtime measurement, statistical analysis and unit test tooling — plan your automation to leverage tighter integrations as they arrive. Keep an eye on tooling market changes and device availability for lab instrumentation; deal trackers can help you spec and buy hardware affordably: Green Deals Tracker and Eco Power Sale Tracker.

Call to action

If you manage embedded releases, start by adding a single static timing check to your PR pipeline this week. Use the sample scripts and patterns here as a blueprint. Need a tailored runbook for your toolchain and hardware lab? Contact our team at whata.cloud for a hands-on workshop where we map these gates to your safety case and implement the CI pipelines with 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.