WCET and Real-Time Safety: Practical Steps After Vector Acquires RocqStat

Stop guessing about timing: why timing analysis must be first-class in your safety verification

Pain point: Your embedded system might pass functional tests yet still fail in the field because some execution path overruns its timing budget. In 2026, with software-defined vehicles, advanced driver assistance, and tightly distributed real-time controllers, timing failures are no longer edge cases — they are safety hazards.

The moment that matters: Vector buys RocqStat and why it changes verification

In January 2026 Vector Informatik announced the acquisition of StatInf's RocqStat technology and team and plans to integrate it into VectorCAST, creating a unified environment for timing analysis, WCET estimation and software verification across embedded projects. The move answers a pressing market need: combine deep timing analytics with mature code testing workflows so teams can verify not just what the software does, but how long it can take to do it.

"Timing safety is becoming a critical ..." — Eric Barton, SVP Code Testing Tools, Vector

Why timing analysis matters in 2026 (short, urgent list)

• Safety impact: Missed timing budgets cause control instability and hazards in automotive, aerospace, medical devices and industrial automation.
• System complexity: Multicore, shared buses, caches, and heterogeneous accelerators make execution time non-deterministic without analysis.
• Regulatory pressure: Standards and certification expectations (ISO 26262, DO-178C, IEC 61508) increasingly require demonstrated timing guarantees.
• Shift-left verification: Dev teams must find timing regressions earlier — preferably in CI — not during late-system integration.
• Cost of failure: Late-stage timing fixes are expensive, often requiring re-architecture or hardware changes.

What RocqStat brings to VectorCAST: practical improvements

RocqStat’s timing analysis capabilities focus on robust WCET estimation via combined static analysis and measurement-based validation. Integrating those capabilities into VectorCAST delivers several practical benefits:

• Unified workflow: One toolchain for unit testing, integration tests and timing proofs reduces context switching and artifacts drift.
• Trace correlation: Link function-level timing budgets to test traces and test cases already managed in VectorCAST for traceable verification evidence.
• Automated regression detection: Trigger CI gates on timing regressions with the same rigor as functional test failures.
• Hardware-aware models: Model CPU pipelines, caches and buses so WCET estimates reflect real target behavior instead of optimistic assumptions.
• Expert continuity: The RocqStat team joining Vector helps preserve domain knowledge for advanced timing problems.

2026 trends that make WCET and timing analysis critical

Late 2025 and early 2026 brought accelerated adoption of software-defined architectures in automotive and industrial domains. A few trends to watch:

• Consolidation of ECUs: Tasks that used to run on isolated microcontrollers are now consolidated on multicore SoCs — increasing interference and timing unpredictability.
• Real-time ML inference: Edge ML pipelines in ADAS and medical devices generate sporadic CPU/GPU load spikes that can blow up WCET if not analyzed.
• Demand for evidence: Certification authorities expect quantitative timing evidence earlier in development cycles.

Core concepts: what your team must understand about WCET

Before you can apply RocqStat-enhanced workflows, make sure your team distinguishes these key concepts:

• WCET vs. average-case: WCET is the provable upper bound across all feasible execution paths and environment behaviors; average-case measurements hide worst-case risk.
• Path explosion: Static path enumeration grows exponentially; good tools use pruning, context sensitivity and loop-bound deduction.
• Hardware modeling: Caches, pipelines, and buses are first-order effects — model them or your WCET will be optimistic.
• Hybrid analysis: Combine static analysis (safe upper bounds) with measurement-based validation to reduce over-conservatism.

Actionable integration plan: from VectorCAST tests to certified timing evidence

Here’s a practical, step-by-step plan to integrate RocqStat into an existing VectorCAST-driven workflow and produce audit-ready timing verification artifacts.

1) Baseline: inventory targets, tasks, and timing contracts

• List all real-time tasks, interrupts and their nominal budgets.
• Create timing contracts per function or component: worst-case budget, best-case, and acceptable jitter.
• Identify hardware platforms for which WCET must be certified (variants, clock speeds).

2) Add hardware models

• Capture CPU microarchitecture, cache sizes/associativity, bus arbitration policy and timer behavior.
• Use RocqStat model templates or develop a concise platform description file.

3) Instrument tests and collect traces

Retain your VectorCAST unit and integration tests and augment them with timing hooks. Measurement traces provide valuable evidence for hybrid WCET workflows.

# Pseudocode CI stage
build: make TARGET=target1
flash: vectordat -flash build/image.bin
run-tests: vectarun --tests all --trace ./traces
collect: rocqstat-collector --input ./traces --target model.json --out measurements.db

When you add trace collection, tie traces back to the documentation and platform models so auditors can reproduce the environment.

4) Launch static WCET analysis

Run RocqStat’s static engine against compiled binaries (preferred) or source ASTs to compute safe upper bounds. Expect to iterate on loop bounds and annotations.

# Pseudocode command
rocqstat analyze --binary build/image.elf --platform model.json --output wcet-report.json

Make static passes part of your regular dev pipeline — tie results into developer productivity metrics so teams treat timing as a first-class CI signal.

5) Correlate test traces with static estimates

Use VectorCAST’s trace-to-test mapping to show which test cases exercise worst-case paths. Where static estimates are overly conservative, measurement evidence can validate or focus refinement.

6) CI gating and regression detection

• Fail CI when WCET increases beyond a configurable delta or violates timing contracts.
• Produce human-readable diffs that point to functions or loops causing regressions.

7) Certification package

• Export VectorCAST test evidence, RocqStat WCET proofs, hardware models and trace mappings into a single verification bundle.
• Include traceability matrices to standards (ISO 26262/DO-178C or domain-specific requirements).

Dealing with hard problems: multicore and shared resources

Multicore WCET remains one of the hardest verification problems in 2026. Key strategies:

• Isolation: Run high-criticality tasks on reserved cores or use hypervisor-based partitioning to reduce interference.
• Interference models: Incorporate measured/pessimistic models of shared bus and memory interference into the WCET analysis.
• Time-triggered scheduling: Where feasible, use time-triggered or time-division multiplexing for the tightest timing guarantees.
• Hybrid scheduling proofs: Combine model checking of schedules with static WCET per task to prove system-level timing properties.

Case study: Tier-1 automaker prototype (composite example)

This composite case summarizes lessons from several early RocqStat customers and shows what to expect when VectorCAST adds RocqStat capabilities.

Situation: A Tier-1 supplier developing a fused perception ECU consolidated several ADAS functions on a 4-core SoC. Functional tests passed, but integration runs showed occasional missed deadlines under sensor burst workloads.

Approach:

• Instrumented VectorCAST unit and system tests to capture execution traces during sensor bursts.
• Modeled the SoC with RocqStat’s hardware templates and ran static WCET analysis on critical perception and fusion functions.
• Used hybrid analysis: static bounds for task maxima, measurements to validate interference profiles and refine scheduling.

Outcomes:

• Identified two functions with underestimated loop bounds; a small refactor eliminated the pathological path.
• Introduced a time-partition for critical control tasks and added CI gating for WCET regressions.
• Delivered a consolidated verification artifact for ISO 26262 evidence showing WCET proofs linked to test traces.

Lesson: Combining RocqStat’s timing analyses with VectorCAST’s test artifacts converts vague timing risk into actionable engineering tasks and certifiable evidence.

Practical tips for teams starting today

• Start with critical paths: Don’t analyze everything at once. Prioritize control loops and safety-critical tasks with tight budgets.
• Automate collection: Add trace collection to CI and make timing data part of every merge request.
• Keep hardware models lean: Capture the dominant timing features first (cache sizes, bus arbitration). Expand only when estimates are too conservative.
• Annotate code: Use explicit loop bounds and timing contracts so static tools can reason precisely.
• Use hybrid evidence: Combine static WCET bounds with measurement traces and stress tests to reduce false positives while staying safe.

Common pitfalls—and how RocqStat+VectorCAST helps you avoid them

• Pitfall: Relying only on measurements. Measurements miss rare worst-case paths. Solution: use static WCET to bound all feasible behavior.
• Pitfall: Over-conservative estimates stop delivery. Solution: hybrid workflows reduce pessimism by validating static assumptions with traces.
• Pitfall: Tests and proofs live in silos. Solution: integration brings test traces and timing proofs into the same lifecycle so evidence is synchronized.

Tooling and sample CI integration (example YAML)

Below is a compact example of how you might add a timing-analysis stage to your existing CI. This is illustrative pseudo-YAML you can adapt to your CI system.

stages:
  - build
  - test
  - run-traces
  - timing-analysis

build:
  script: make TARGET=board

unit-tests:
  script: vectarun --tests unit --out unit-traces

run-traces:
  script:
    - vectarun --tests system --out system-traces
    - rocqstat-collector --input system-traces --output measurements.db

timing-analysis:
  script:
    - rocqstat analyze --binary build/image.elf --platform board-model.json --measurements measurements.db --output wcet.json
    - rocqstat compare --baseline baseline/wcet.json --current wcet.json --threshold 0.05
  when: on_success

Preparing for certification in 2026: what auditors want

Certification authorities increasingly expect:

• Traceable links between requirements, tests and timing proofs.
• Hardware descriptions used in WCET proofs and their validation steps.
• Evidence that WCET regressions are monitored in CI and acted upon.

Consolidating test evidence and timing proofs into a single toolchain simplifies auditor review and reduces rework.

Future predictions: what the next 2–3 years will bring

Looking ahead from 2026:

• More toolchain consolidation: Expect more acquisitions and integrations that combine testing, static analysis and timing proofs.
• Executable assurance artifacts: Verification bundles that auditors can run to reproduce traces and timing proofs will become standard — think reproducible platform manifests and indexed manuals.
• AI-assisted timing analysis: Machine learning will help prioritize path analysis and suggest loop bounds, but formal-proof components will remain critical.

Final checklist: get timing-safe in 90 days

1. Inventory critical tasks and set timing contracts (week 1–2).
2. Integrate trace collection into existing VectorCAST tests (week 2–4).
3. Run first RocqStat static WCET passes and compare to measurements (week 4–8).
4. Automate timing checks into CI and set up regression alerts (week 8–10).
5. Assemble verification package for stakeholders and early audits (week 10–12).

Closing — timing is verification, not a side-effect

In 2026, timing analysis has moved from niche research to an operational discipline. Make it part of your CI, your test evidence, and your certification artifacts — and remember that clear platform models and traceability are the only paths to audit-ready WCET proofs.

Related Reading

• Developer Productivity and Cost Signals in 2026: Polyglot Repos, Caching and Multisite Governance
• Observability in 2026: Subscription Health, ETL, and Real‑Time SLOs for Cloud Teams
• Indexing Manuals for the Edge Era (2026): Advanced Delivery, Micro‑Popups, and Creator‑Driven Support
• Field Review: Compact Edge Appliance for Indie Showrooms — Hands-On (2026)
• Sustainable Alternatives to Synthetic Dog Coats: Artisan‑Made Pet Accessories
• Pandan for Beginners: A Shopper’s Guide (Fresh, Frozen, Paste, Extract)
• Transparent Payouts: What Panels Can Learn from Principal Media Transparency Advice
• What Ground Transport Can Learn from the UPS Plane Part Failure: Fleet Maintenance Transparency
• Biotech Meets the Plate: Cell-Based Proteins, Precision Fermentation, and What Diners Should Ask