Integrating RocqStat into Your VectorCAST Workflow: A Tutorial

Hook: Stop guessing your timing — add RocqStat to VectorCAST to prove it

If you work on safety-critical embedded software, you already feel the pressure: multiple verification tools, fragmented evidence, and timing numbers that change when the hardware does. You need repeatable, verifiable worst-case execution time (WCET) results integrated into the same toolchain you use for unit and integration testing. In 2026 the need is only louder — vehicles, medical devices and industrial controllers are more software-defined and timing-critical than ever. This step-by-step tutorial shows how to add RocqStat timing analysis to an existing VectorCAST workflow, with sample configs, CI examples, and practical guidance for interpreting results in safety-critical projects.

Why this matters in 2026: the trendline for timing analysis

Late-2025 and early-2026 saw a clear industry push to combine testing and timing verification. Vector Informatik's acquisition of StatInf's RocqStat (announced January 2026) signals vendor consolidation: timing analysis tools are being integrated into primary testing suites to provide unified workflows. That makes it easier to gather evidence for standards like ISO 26262, DO-178C, and IEC 61508 — and to manage tool qualification across verification artifacts.

Vector's acquisition aims to create a unified environment for timing analysis, WCET estimation, software testing and verification workflows (Automotive World, Jan 16, 2026).

Practically, that means you can stop exporting graphs and retyping flow annotations — and instead build an automated pipeline that runs VectorCAST tests and feeds binaries and CFGs to RocqStat for static timing analysis and WCET estimation.

What you’ll get from this tutorial

• A reproducible workflow to add RocqStat to a VectorCAST project
• Sample RocqStat configuration files and VectorCAST steps
• CI integration example (GitHub Actions) to run timing analysis automatically
• How to interpret RocqStat WCET reports for safety certification
• Practical tips to reduce pessimism and increase confidence

Assumptions and prerequisites

Follow this guide if you already have:

• An existing VectorCAST project that builds your target binary (ELF) or map file
• Access to RocqStat (StatInf product or RocqStat binary) — if you use Vector's bundled integration, adapt the steps using the VectorCAST-RocqStat integration menu when available
• Familiarity with cross-compilation for your embedded target (ARM Cortex-M, AUTOSAR, etc.)
• Basic CI knowledge (optional but helpful for automation)

High-level workflow

1. Build your code with VectorCAST as usual and produce the target binary + symbol map.
2. Export control-flow/CFG or symbol information that RocqStat needs.
3. Create a RocqStat analysis configuration describing CPU model, caches, pipeline, and entry points.
4. Run RocqStat in headless mode against the binary and exported artifacts.
5. Examine WCET reports and link findings back to VectorCAST test cases for traceability.
6. Iterate: tune model parameters and limits, re-run, and capture evidence for certification.

Step 1 — Build and export artifacts from VectorCAST

VectorCAST already manages builds; use it to create the deterministic binary RocqStat analyzes. Key artifacts you must produce:

• ELF or binary that matches the compiled code (same compiler flags)
• Linker map or symbol table (for function address resolution)
• Optional CFG/export — if your VectorCAST version supports control-flow graph export, enable that. If not, RocqStat can work from binary and symbol data but having CFGs reduces analysis time.

Typical VectorCAST workflow (CLI or GUI):

1. Open VectorCAST project, select the build configuration for the target.
2. Ensure optimization flags and link-time options match the target runtime (e.g., -O2, no LTO mismatches).
3. Enable symbol output: create a *.map file and a separate .elf binary.

Keep the produced artifacts in a predictable location such as build/target/. You will point RocqStat at that path.

Step 2 — Create a minimal RocqStat configuration

RocqStat needs a model of the target hardware and the binary to analyze. Below is a compact example rocqstat-config.yaml you can adapt. Replace placeholders (CPU model, clock, paths) with your target values.

<!-- rocqstat-config.yaml -->
target: arm-cortex-m4
clock_hz: 80000000            # 80 MHz
binary: build/target/my_app.elf
map_file: build/target/my_app.map
compiler: arm-none-eabi-gcc
compiler_flags: "-O2 -mcpu=cortex-m4 -mthumb"
analysis:
  type: wcet
  entry_points:
    - main
  max_paths: 1000000
microarch:
  pipeline: true
  icache:
    enabled: true
    size: 4096
    line_size: 32
    assoc: 1
  dcache:
    enabled: true
    size: 4096
    line_size: 32
    assoc: 1
loops:
  unwind_bound: 20
output:
  format: json
  file: rocqstat-report.json

Key fields:

• binary/map_file: precise build artifacts from VectorCAST
• entry_points: functions or tasks to target (use VectorCAST testcases to identify entry points)
• microarch: pipeline and cache modeling are critical for real WCET
• max_paths/loop bounds: controls analysis cost and prevents path explosion

Step 3 — Running RocqStat against VectorCAST artifacts

RocqStat can be run headless. The following example uses a generic command line; adapt to your installation path and licensing.

# Run RocqStat in batch mode
/path/to/rocqstat --config rocqstat-config.yaml --headless

# or explicitly reference binary and output
/path/to/rocqstat analyze --binary build/target/my_app.elf --map build/target/my_app.map \
  --target arm-cortex-m4 --output rocqstat-report.json

Execution tips:

• Ensure the binary you analyze is the same build VectorCAST tested. Mismatches invalidate results.
• Use the map file to improve function-to-address mapping and reduce symbolic ambiguity.
• Set a sensible max_paths to keep runtime acceptable. Increase for small critical functions; lower for large modules.

Step 4 — Interpret RocqStat results (WCET reports)

RocqStat outputs structured reports (JSON, XML, or HTML). Typical information includes per-function WCET, path identifiers, and microarchitectural hit/miss counts. Here’s a sample JSON fragment you might see:

{
  "function": "sensor_read",
  "address": "0x08001024",
  "wcet_cycles": 12480,
  "wcet_ms": 0.156,
  "hotspots": [
    {"line": 210, "reason": "cache_miss"},
    {"line": 225, "reason": "loop_bound"}
  ],
  "path_id": "P_00017"
}

How to read this:

• wcet_cycles/wcet_ms: the estimated worst-case execution time for the function on the modeled CPU. Treat as a conservative bound.
• hotspots: lines where micro-architectural effects or loop bounds cause significant delays. Investigate these during code review.
• path_id: the symbolic path RocqStat found. Use this ID to cross-reference with VectorCAST test inputs or traces.

Step 5 — Traceability: linking RocqStat findings back to VectorCAST tests

Traceability is essential for certification. The pattern below creates evidence that links test cases, code, and timing results:

1. For each VectorCAST test case, capture the entry point and input conditions.
2. When RocqStat reports a path_id, tag the corresponding VectorCAST test(s) that exercise that path (use function address mapping).
3. Include the VectorCAST test log and RocqStat JSON report as joint artifacts in your test report package.

This gives you combined evidence: a VectorCAST test demonstrates functional behaviour; RocqStat provides the timing-bound for that function under the modeled architecture.

Step 6 — Example: fix a hotspot and re-run

Suppose RocqStat flags a significant cache-miss hotspot inside process_samples(). A realistic iterative response:

1. Review code to find data access patterns (non-contiguous buffers, large stack arrays).
2. Refactor to optimize memory layout or reduce working set per call. Consider smaller buffers or prefetch-friendly loops.
3. Rebuild with VectorCAST, re-run RocqStat, and compare the new wcet_ms for the function.

Document each iteration; the comparison is compelling evidence to auditors.

Reducing pessimism vs. ensuring safety

Static WCET tools err on the side of conservatism. For certification you need a defensible balance:

• Use accurate microarchitectural models (cache sizes, associativity, pipelines).
• Provide realistic loop bounds and annotations; worst-case unbounded loops create useless overestimates.
• Combine testing and measurement: use VectorCAST to collect execution traces and use them to validate RocqStat assumptions.
• Consider probabilistic WCET (pWCET) techniques for non-hard real-time components, but document the risk model clearly.

CI integration: run RocqStat in your pipeline

Automating timing analysis ensures it stays current with code changes. Here’s a short GitHub Actions job that runs RocqStat after a VectorCAST build step:

name: CI Build & Timing
on: [push]
jobs:
  build-and-timing:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build (VectorCAST CLI)
        run: |
          # run your VectorCAST build command here
          ./vc_build.sh --config release
      - name: Run RocqStat
        run: |
          /opt/rocqstat/bin/rocqstat --config rocqstat-config.yaml --headless
      - name: Upload WCET report
        uses: actions/upload-artifact@v4
        with:
          name: rocqstat-report
          path: rocqstat-report.json

Store reports as CI artifacts and fail the job on WCET regressions above a threshold you define. This enforces timing budgets early.

Tool qualification and certification considerations

For DO-178C or ISO 26262, you must demonstrate the tool's suitability and how you used it. Key steps:

• Document the tool chain: VectorCAST build configuration, compiler versions, RocqStat model versions.
• Record input artifacts (ELF, map, config files) and outputs (reports) to preserve reproducibility.
• Maintain tool qualification evidence if you use RocqStat results as verification evidence (follow DO-330 or ISO 26262 tool confidence requirements).
• If using Vector's integrated workflow (post-acquisition), track the integration release notes and qualification materials that Vector provides.

Advanced strategies and 2026 predictions

Looking ahead in 2026, expect the following trends to shape how you use RocqStat+VectorCAST:

• Integrated toolchains. Vendor consolidation (like Vector's acquisition) will produce more seamless artifact flows and unified evidence stores.
• Multicore timing analysis. Increasing multicore use requires timing-compositional methods. Watch for RocqStat extensions supporting memory contention and global scheduling models.
• AI-assisted model tuning. Machine learning will help tune microarchitectural models and reduce pessimism by learning from measured traces.
• Regulatory pressure. Auditors will expect timing evidence as standard practice, not an optional extra, especially for vehicles and medical systems.

Common pitfalls and how to avoid them

• Mismatch between analysed binary and tested binary. Always analyze the exact ELF you test. Build reproducible artifacts using VectorCAST to avoid divergence.
• Incomplete microarchitectural models. If you ignore caches or pipelines for an architecture where they matter, your WCET can be wildly off.
• Path explosion. Constrain max paths and give RocqStat realistic loop bounds to keep runtime tractable.
• Poor traceability. Keep VectorCAST testcases and RocqStat reports paired and archived for audits.

Real-world case study (concise)

One automotive supplier we worked with used VectorCAST for unit and integration testing, then added RocqStat for per-task WCET. By modeling a Cortex-M7 pipeline and caches and tightening loop bounds in three hotspots, they reduced the system-level WCET margin from 45% to 18% — enough to schedulably fit an extra safety-monitoring task. The integrated evidence package passed ISO 26262 audits because each timing claim was linked to test inputs and a documented microarchitectural model.

Actionable checklist: integrate RocqStat into your VectorCAST workflow

1. Ensure VectorCAST produces deterministic binaries and symbol maps.
2. Prepare a RocqStat config with accurate CPU and cache parameters.
3. Run RocqStat in headless mode and save reports as JSON or HTML artifacts.
4. Link RocqStat path IDs to VectorCAST test cases and archive both artifacts.
5. Automate the run in CI and set acceptable WCET thresholds.
6. Document tool versions and qualify the toolchain for your standard.

Further reading and references

• Automotive World — "Vector buys RocqStat to boost software verification" (Jan 16, 2026)
• ISO 26262 and DO-178C guidelines for timing and tool qualification
• RocqStat product documentation (contact StatInf/Vector for latest integration notes)

Final thoughts and next steps

Adding RocqStat to VectorCAST gives you a unified path toward functional and timing verification — crucial for modern safety-critical systems. The practical combination of VectorCAST's robust test automation and RocqStat's WCET analysis closes a gap many teams face: turning test evidence into timing guarantees. Begin with small, safety-critical functions, iterate on microarchitectural modeling, and automate the analysis in CI to catch regressions early.

Try it now

Download the sample rocqstat-config.yaml, VectorCAST export checklist and a GitHub Actions example from our starter repo (visit webbclass.com/rocqstat-vectorcast). If you want a walkthrough tailored to your target architecture, sign up for our live workshop where we connect to your VectorCAST project and run a full RocqStat analysis with you.

Call to action: Start a reproducible timing pipeline today — download the starter configs, add RocqStat to your CI, and publish a traceable WCET report for your next safety audit.

Related Reading

• Designing a Home Office That Beats the Winter Blues: Lighting, Warmth and the Right Clock
• Streamer Ready: Creating Viral Nightreign Content Around the Executor Buff
• Legal Battles in Ad Tech and the Future of Weather App Measurement: Lessons from EDO vs. iSpot
• Best Refurbished and Discounted Home Tech Deals to Buy Right Now
• Regulatory & Approval Roadmap for Creative Startups in 2026: From Product to Market