Hands-on WCET Analysis with RocqStat and VectorCAST: From Setup to Report

Cut WCET uncertainty, not development velocity: integrate RocqStat into VectorCAST

If you're shipping safety-critical embedded software in 2026, you face two brutal facts: timing budgets are shrinking and regulatory scrutiny is increasing. Teams still rely on disconnected tools for unit testing and timing analysis, which produces brittle evidence and wasted cycles. This hands-on tutorial walks you through a practical VectorCAST + RocqStat workflow so you can run reliable WCET analyses, interpret results, and fold them into verification reports and CI/CD gates.

Why this matters now (2026)

In January 2026 Vector Informatik acquired StatInf's RocqStat technology and engineering team to merge timing-analysis capability directly into the VectorCAST ecosystem. That acquisition signals a broader trend: toolchains that combine functional testing and timing analysis are becoming standard for automotive, aerospace, and other real-time domains. Expect certification expectations (ISO 26262, DO-178C style artifacts) to demand tighter traceability between test evidence and WCET proof artifacts. If your verification artifacts are fragmented, you'll pay in time and audit friction.

"Timing safety is becoming a critical piece of software verification." — Vector announcement, Jan 2026

Overview: The workflow you'll implement

This guide shows an end-to-end pattern you can adopt today while Vector completes the official integrated release. We'll cover:

• Environment and prerequisites
• Instrumenting builds for RocqStat analysis
• Running static and hybrid WCET analyses
• Interpreting per-function and end-to-end WCET results
• Embedding results into VectorCAST verification reports
• Automating checks in CI/CD with pass/fail rules and artifact publishing

Prerequisites and setup

Before you begin, set up a reproducible environment. This guide assumes a Linux-based CI runner and access to VectorCAST (local or server) and RocqStat (standalone or integrated plugin). If you use Vector's upcoming integrated release, replace standalone steps with the equivalent VectorCAST plugin workflows.

Software & hardware

• VectorCAST 2025.x or later (server/CLI access recommended)
• RocqStat (StatInf) binaries or the Vector-integrated RocqStat plugin
• Cross-compiler toolchain for your target (GCC/LLVM for embedded, or vendor compiler)
• Optional: QEMU or a hardware-in-the-loop (HIL) board for measurement-based calibration

Repository layout

Organize your repo so build and timing artifacts are deterministic:

project/
  ├─ src/
  ├─ include/
  ├─ tests/
  ├─ build/
  ├─ rocqstat-config/
  └─ vectortest/
  

Step 1 — Build artifacts suitable for WCET analysis

WCET tools require symbol information and deterministic builds. Two practical rules:

• Keep linker maps and ELF objects for analysis.
• Enable compiler options that preserve control-flow (avoid aggressive link-time optimizations that remove symbol-level granularity unless you model them).

Recommended GCC flags

Example compile flags (adjust for your toolchain):

-Os -g -fno-inline-small-functions -fno-omit-frame-pointer -fno-strict-aliasing
  -ffunction-sections -fdata-sections -Wl,--gc-sections
  

Why: keep function boundaries and debug symbols to allow RocqStat to map control-flow graphs to source lines and generate traceable WCET evidence.

Step 2 — Configure RocqStat analysis

RocqStat supports static analyzers and hybrid approaches (static analysis with measurement-based calibration). The key inputs are:

• ELF/binary of the compilation unit
• Linker map or symbol table
• Platform model: clock frequency, cache sizes, pipeline details (or a conservative abstract model)
• Optional execution traces for calibration (from QEMU or HIL)

Example rocqstat-config layout

rocqstat-config/
  ├─ platform.yaml     # cpu, cache, memory latency
  ├─ entry_points.txt   # functions / tasks to analyze
  └─ options.json       # static vs. hybrid, timeouts
  

Minimal platform.yaml (example)

cpu:
    model: generic-cortex-m7
    frequency_mhz: 600
  cache:
    i_cache_kb: 32
    d_cache_kb: 32
    line_size: 32
  pipeline:
    stages: 6
  

Note: Replace values with measured hardware specs. For high-assurance artifacts you should prefer measured parameters or vendor-provided microarchitectural models.

Step 3 — Running RocqStat (static and hybrid)

There are two common modes:

1. Pure static analysis — fast, conservative. No execution traces required.
2. Hybrid (static + measurement) — uses traces to tighten WCET bounds; requires calibrated measurement runs.

Static run (CLI example)

# prepare artifacts
  cp build/firmware.elf rocqstat-input/
  cp build/firmware.map rocqstat-input/

  # run rocqstat (placeholder CLI)
  rocqstat analyze --input rocqstat-input/firmware.elf \
      --map rocqstat-input/firmware.map \
      --platform rocqstat-config/platform.yaml \
      --entries rocqstat-config/entry_points.txt \
      --output rocqstat-results/static
  

Output: per-function WCET estimates, worst paths, and a global worst-case bound. Expect the static WCET to be conservative; that's normal.

Hybrid run: collect traces then calibrate

Use a representative test harness to collect execution traces that exercise hot paths. QEMU with cycle-accurate models or an instrumented HIL board are valid sources. The goal: provide path frequency information and measured latencies to reduce infeasible path cost inflation.

# collect traces (example using QEMU or hardware trace logger)
  ./run_on_qemu.sh --trace traces/run1.trace --cmd "tests/my_test"

  # feed traces into RocqStat calibration
  rocqstat calibrate --input firmware.elf \
      --trace traces/run1.trace \
      --platform rocqstat-config/platform.yaml \
      --output rocqstat-results/hybrid
  

Step 4 — Interpreting WCET output

RocqStat will produce several artifacts. Focus on these:

• Function-level WCET — conservative upper bound per routine, useful for local reasoning and test prioritization.
• Call-graph / path report — identifies the worst-case calling sequence and basic-block costs contributing most to WCET.
• Confidence/certainty metrics — indicate where the analysis used conservative assumptions vs. measurement evidence.
• WCET proof files — artifacts that show assumptions (platform model, input constraints) necessary for certification evidence.

What to look for

• Top contributors: Functions or loops with high cache-miss penalties or large loop bounds.
• Unbounded loops or dynamic inputs: these need annotations or constraints to be analyzable.
• Large gap between static and hybrid WCET: indicates your traces didn't exercise worst-case or platform model is too conservative.

Example snippet of a report summary

Worst-case path: task_main -> process_packet -> decode_frame
  WCET (static): 22.3 ms
  WCET (hybrid): 13.1 ms (calibrated with 10 trace runs)
  Confidence: medium (cache model uses conservative associativity)
  

Step 5 — Feed WCET into VectorCAST verification reports

VectorCAST already produces structured test evidence (XML/HTML). The goal is to embed WCET artifacts so test reports show timing compliance side-by-side with functional test results.

Integration strategies

• Attach WCET artifacts (PDF, XML, JSON) as supplemental artifacts inside the VectorCAST report directory.
• Map WCET values to specific VectorCAST test cases or test suites using a small XML mapping file so reports show per-test timing budgets and measured WCET.
• Use VectorCAST's report templating or server plugin (when available) to surface WCET summary tables.

Example XML snippet to attach to a VectorCAST result package

<wcetReport>
    <artifact>rocqstat-results/hybrid/summary.json</artifact>
    <target>task_main</target>
    <wcet_ms>13.1</wcet_ms>
    <method>rocqstat-hybrid</method>
    <confidence>medium</confidence>
  </wcetReport>
  

Place the XML alongside VectorCAST's run results. If you use VectorCAST Server, configure the evidence import to include these artifacts for auditors and traceability matrices.

Step 6 — Automate and gate WCET in CI/CD

To prevent regressions, run WCET analyses as part of your pipeline. Full static runs are fast enough for nightly or PR-level checks if scoped to changed modules. Hybrid runs are longer—use them for nightly or release pipelines.

Example GitHub Actions workflow

name: wcet-pipeline
  on: [push, pull_request]
  jobs:
    build-and-wcet:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v4
        - name: Build firmware
          run: ./build.sh --out build/firmware.elf
        - name: Run VectorCAST unit tests
          run: vectortest/run_vectorcast.sh --project vectortest/project.vcast
        - name: Run RocqStat static analysis
          run: |
            rocqstat analyze --input build/firmware.elf \
              --map build/firmware.map --platform rocqstat-config/platform.yaml \
              --entries rocqstat-config/entry_points.txt \
              --output rocqstat-results/static
        - name: Fail on WCET regression
          run: |
            python tools/check_wcet_threshold.py \
              --report rocqstat-results/static/summary.json \
              --thresholds wcet-thresholds.yaml
  

Threshold strategy

Define thresholds per-module (absolute time) and per-release (percentage). Use the pipeline to fail PRs that push a critical function above its allowed budget. For exploratory branches, allow the pipeline to post comments instead of failing immediately.

Dealing with common challenges

1) Over-conservative WCET bounds

• Use hybrid analysis and increase trace coverage for the hot paths.
• Refine platform model by measuring cache latencies and pipeline behavior on representative hardware.
• Add source annotations (loop bounds, input ranges) to reduce infeasible path exploration.

2) Dynamic language/runtime features

High-level languages or dynamic features (reflection, dynamic dispatch) make static analysis harder. Options:

• Restrict dynamic behavior in safety-critical partitions or provide runtime invariants in analysis metadata.
• Use measured worst-case timings from instrumented runs if static proof is infeasible and document assumptions clearly.

3) Certification traceability

For ISO 26262/DO-178 style artifacts, ensure your report bundle contains:

• Input artifacts: ELF, map, platform model
• Analysis settings and versions (RocqStat and VectorCAST versions)
• Trace evidence used for hybrid runs
• WCET proof artifacts and mapping to system-level timing requirements

Case study: Reducing WCET by 40% on a packet-processing task

In a recent validation (internal), a team used a hybrid RocqStat + VectorCAST flow to analyze a packet-processing task. Static WCET was 22.3 ms; after targeted trace-driven calibration and a loop-bound annotation, the hybrid WCET dropped to 13.1 ms. The workflow included:

1. Unit tests in VectorCAST to exercise functional paths and produce representative traces.
2. QEMU-driven trace collection for edge-case inputs.
3. RocqStat hybrid analysis and per-function backtracing to identify hot-loop bounds.
4. Verification report update where the VectorCAST report showed both unit-test pass rates and the new WCET proof attached.

Outcome: the reduced WCET unlocked a tighter system schedulability margin and avoided an over-engineered hardware upgrade.

Advanced strategies and future-proofing

As tooling converges (VectorCAST embedding RocqStat capabilities), expect the following trends through 2026:

• Tighter toolchain integration: Less manual artifact shuffling as timing analysis becomes a first-class citizen in VCT pipelines.
• Model-based WCET: Platform models will be standardized, and vendors will ship certified microarchitectural descriptions to improve accuracy.
• Runtime monitoring + offline analysis: Hybrid workflows will combine field telemetry with pre-deployment WCET artifacts to detect drift or environmental effects.

Practical advice to stay ahead

• Automate the collection of platform configuration and include it in your repo so analyses are reproducible.
• Scope static WCET runs to the changed modules for fast PR feedback, and run full-system hybrid analyses at night.
• Maintain a WCET database with historical values to recognize regressions early and measure the impact of code changes on timing budgets.

Checklist: What to include in your verification bundle

• ELF/binary and map files
• RocqStat configuration and platform model
• Trace files used for calibration
• RocqStat output (JSON/XML summaries, worst-path diagrams)
• VectorCAST test evidence and mapping XML linking tests to analyzed functions
• Change history and thresholds file used by CI gates

Wrap-up: Key takeaways

• Integrate early: Add WCET analysis to CI (static per-PR, hybrid nightly) to detect regressions fast.
• Use hybrid runs: Measurement-based calibration with RocqStat often produces much tighter and actionable WCET bounds.
• Make artifacts auditable: Keep platform models, traces, and proof files in the verification bundle for certification readiness.
• Automate gating: Fail builds on unacceptable WCET regressions and post diagnostics for triage.

Further reading and next steps

Follow Vector's 2026 announcements for the official VectorCAST + RocqStat integration to replace the standalone steps in this guide with first-class plugins. Meanwhile, adopt the workflow above to get immediate value:

1. Start with static RocqStat runs scoped to changed modules in PRs.
2. Add hybrid calibration for nightly runs with representative test vectors.
3. Embed RocqStat summaries into VectorCAST reports and automate CI gating.

Call to action

Ready to remove timing uncertainty from your verification artifacts? Start a pilot: wire RocqStat static analysis into your VectorCAST pipeline for one critical component this week. If you want a checklist or CI templates tailored to your toolchain (Jenkins, GitHub Actions, GitLab CI), download the sample repo and runner scripts we use internally or contact your Vector account rep for early-access integration guidance.

Related Reading

• Protecting Wallets from Autonomous AIs: Policy & Architecture for Enterprises
• Nearshore AI squads vs. local cloud teams: hiring trade-offs and cost models
• Predictive Alerts for Operators: Using Market Signals to Plan Weekend Staffing
• Where to Buy Affordable Yoga Tech Deals This January (Smart Lamps, Watches and More)
• Casting the Next Table: How Critical Role’s Rotating Tables Inform Long-Form Space RPG Campaigns