Best Practices for Timing Analysis in Real-Time Applications: From Theory to VectorCAST + RocqStat

Beat release delays and timing surprises: a practical guide to WCET and timing analysis with VectorCAST + RocqStat in embedded CI (2026)

If you ship safety-critical firmware, you already know the pain: late-stage timing regressions, ambiguous WCET numbers, and manual profiling that blocks releases. In 2026 the pressure is greater—software-defined vehicles, ADAS features, and edge robotics demand provable timing guarantees. This tutorial-style guide shows how to build a repeatable timing analysis workflow, combine static analysis and profiling, and automate Worst-Case Execution Time (WCET) checks using the newly integrated RocqStat features inside VectorCAST—all in an embedded CI pipeline.

Why this matters now (2026 trends)

Late 2025 and early 2026 saw consolidation in the timing tools market. Vector Informatik's acquisition of StatInf's RocqStat technology signalled a push to unify timing analysis with software verification tools. As reported January 16, 2026, Vector plans to integrate RocqStat into VectorCAST to create an integrated environment for WCET estimation and verification workflows. This matters because teams want a single, auditable toolchain that fits automated CI and safety workflows (ISO 26262, DO-178C guidance on timing verification).

"Vector will integrate RocqStat into its VectorCAST toolchain to unify timing analysis and software verification." — Automotive World, Jan 16 2026

At-a-glance: the timing analysis workflow

Below is a practical, repeatable workflow you can adopt today. Each step includes tools and automation ideas to make timing checks part of your CI/CD pipelines.

1. Model the system and requirements — define timing budgets, activation patterns, and safety margins.
2. Static WCET analysis — use RocqStat's static/abstract interpretation to produce conservative WCET bounds per function and task.
3. Instrumented profiling — collect execution traces on representative hardware to validate paths and discover hotspots.
4. Hybrid reconciliation — combine static WCET and measured distributions to tighten bounds where safe.
5. Automate checks in CI — fail builds on WCET regressions or budget violations; produce evidence artifacts for audits.
6. Continuous monitoring — track trends (mean, P95, WCET) and set alerts for regressions.

Step 1 — Model the system: define the timing problem

Before running tools you must be explicit about what "timing correct" means in your context.

• List tasks, priorities, activation modes (periodic, sporadic, event-driven).
• Define input spaces and environmental assumptions (network latency, sensor rates).
• Specify timing contracts: deadlines, jitter budgets, and safety margins.
• Capture hardware model: CPU type, caches, timers, multi-core sharing, interrupt behavior.

Good models reduce false positives from static analyzers and make measured tests reproducible.

Step 2 — Static WCET analysis with RocqStat (now through VectorCAST)

RocqStat uses path-sensitive analysis and abstract interpretation to compute conservative WCET estimates across code paths. When integrated inside VectorCAST, you get the advantage of unified test harnesses, code coverage, and traceability.

Key static-analysis tasks

• Control-flow graph (CFG) construction and loop bound identification.
• Data-flow and pointer analysis to reduce path-explosion.
• Hardware model binding (cache, pipeline, instruction timing).
• Compositional analysis for modular builds.

Actionable tips:

• Annotate loop bounds and assume constraints where justified—this reduces overly conservative WCETs.
• Use VectorCAST test harnesses to supply concrete inputs for interprocedural analysis; this tightens reachable path coverage.
• Keep the hardware model in source control and version it alongside the codebase for reproducibility.

Step 3 — Profiling and measurement-based validation

Static analysis gives safe upper bounds, but measurement-based profiling provides empirical evidence and helps identify hotspots and unrealistic paths. Combine the two for a robust picture.

Instrumentation techniques

• Use instruction trace (ETM, TracePort) for fine-grained path reconstruction.
• Lightweight logging with cycle-accurate timestamps (hardware timers, DWT on Cortex-M).
• Performance counters to measure cache misses and branch mispredicts.
• Statistical profiling (P99, P99.9) from system-level runs to capture rare events.

Practical example: enable VectorCAST trace collection in your unit/integration tests, then feed the produced trace to RocqStat for path validation. This helps eliminate infeasible paths that static analysis still considers.

Step 4 — Hybrid analysis: reconcile static bounds and measurements

Hybrid methods use measured traces to prune infeasible paths and refine bounds. Typical workflow:

1. Run static WCET to get conservative bounds.
2. Generate test inputs that target worst-case CFG regions (use fuzzers or VectorCAST’s test generation).
3. Collect traces on target hardware.
4. Use RocqStat to mark paths as infeasible where evidence exists or to tighten bounds where hardware effects are measured.

Note: conservatism is a safety asset—only remove paths when you have convincing evidence and traceability.

Step 5 — Embed timing checks in CI/CD (example with VectorCAST + RocqStat)

Embedding timing checks in CI reduces surprise regressions. Below is a practical CI example that demonstrates a GitLab CI job flow; same pattern applies to GitHub Actions or Jenkins.

CI stages

1. Build — reproducible cross-compilation in a container.
2. Unit tests — run VectorCAST harnesses and collect coverage & traces.
3. Static timing — run RocqStat (via VectorCAST integration) to produce WCET reports.
4. Measurement validation — execute on-nightly hardware-in-the-loop (HIL) or QEMU with cycle-accurate modeling.
5. Gate — parse reports and fail the pipeline if thresholds are exceeded.

Sample GitLab CI job snippet

# .gitlab-ci.yml (simplified)
stages:
  - build
  - test
  - timing

build:
  stage: build
  image: registry.example.com/embedded-toolchain:latest
  script:
    - ./scripts/cross-build.sh
  artifacts:
    paths: [build/*]

unit-tests:
  stage: test
  image: registry.example.com/vectorcast-cli:latest
  script:
    - vectorcast-cli run --project myproj --harness unit
    - vectorcast-cli export-trace --output traces/unit_trace.etf
  artifacts:
    paths: [traces/*]

wcet-check:
  stage: timing
  image: registry.example.com/vectorcast-rocqstat:latest
  script:
    - rocqstat analyze --project myproj --traces traces/unit_trace.etf --output reports/wcet.json
    - python tools/check_wcet.py reports/wcet.json --threshold 2500  # microseconds
  artifacts:
    paths: [reports/*]

The script tools/check_wcet.py is a simple policy enforcer. If wcet > threshold, job fails. Use strict thresholds in release branches and softer ones for CI on feature branches.

Automating evidence collection

Save the static analysis reports, measured traces, and the exact hardware model used to generate the numbers. These artifacts are essential for audits (ISO 26262 ASPICE) and for debugging regressions later.

Step 6 — Metrics, dashboards and alerting

Make timing visible to your team. Useful metrics:

• WCET per task and per function (conservative statically computed).
• Runtime percentiles (P50/P95/P99/P99.9) from production telemetry or HIL tests.
• Regression delta vs baseline (absolute and relative).
• Path coverage percentage—how many CFG paths validated by tests/traces.

Set up dashboards (Grafana, ELK) and fail-fast alerts in CI when WCET increases beyond a configured threshold.

Advanced strategies and common pitfalls

Multicore and contention

Multicore WCET is hard because of shared caches, buses, and unpredictability. Options:

• Use time-partitioning (tickless RTOS scheduling or ARINC-653 style partitions).
• Simplify hardware model with conservative shared-resource bounds.
• Where possible, isolate critical tasks to dedicated cores.

Calibration and validation

Always calibrate instruction/memory timing with microbenchmarks on the exact silicon revision. RocqStat will be as good as the hardware model you provide.

Toolchain reproducibility

Store VectorCAST project files, RocqStat configs, and tool versions in your repo. Use containers for CI so a developer, the CI system, and auditors run the same binaries.

API and SDK examples: parsing RocqStat/VectorCAST reports

Automated gating needs a parser that extracts WCET numbers and compares them to thresholds. Below is a minimal Python example that reads a RocqStat JSON report and fails if any function WCET exceeds a target.

#!/usr/bin/env python3
import json
import sys

THRESH_MS = 2.5  # example threshold

with open('reports/wcet.json') as f:
    data = json.load(f)

# assume report has entries: [{"function":"foo","wcet_us":1200}, ...]
violations = []
for entry in data.get('functions', []):
    wcet_ms = entry['wcet_us'] / 1000.0
    if wcet_ms > THRESH_MS:
        violations.append((entry['function'], wcet_ms))

if violations:
    print('WCET violations:')
    for fn, w in violations:
        print(f' - {fn}: {w:.3f} ms')
    sys.exit(2)

print('All WCET checks passed')

Replace the JSON schema mapping with the exact shape produced by RocqStat via VectorCAST integration (VectorCAST v2026+ will expose CLI/REST endpoints for report export).

Real-world checklist (quick)

• Define timing budgets in requirements and track them in the backlog.
• Version hardware models alongside code.
• Run static WCET as part of CI; keep the reports as artifacts.
• Collect representative traces on target hardware regularly.
• Use hybrid analysis—do not rely solely on measurements or static results.
• Fail the build on meaningful regressions and alert owners.

Limitations and conservative practices

Be explicit about assumptions. Static WCET is conservative by design; trimming bounds requires evidence. Document why annotations or environment assumptions are valid. For safety cases, preserve auditability: every tightened bound should reference the trace or proof that enabled it.

Future directions (2026+)

Expect deeper integrations between timing analysis and verification tools in 2026 and beyond. Vector’s RocqStat acquisition points toward unified toolchains where test vectors, coverage, static WCET, and trace evidence live in one place—streamlining audits and making embedded CI more robust. In addition:

• AI-assisted path prioritization will suggest test inputs targeting likely worst-cases.
• Cloud-based deterministic emulation combined with silicon-in-the-loop farms will reduce bottlenecks for HIL runs.
• Standards bodies will clarify acceptable hybrid workflows for safety certification.

Actionable takeaways

• Start small: add a nightly WCET job that runs RocqStat via VectorCAST and stores reports.
• Version the hardware model and VectorCAST/RocqStat config next to code.
• Combine static WCET with targeted traces to reduce over-conservatism safely.
• Automate gating in CI with clear thresholds and alerting for regressions.
• Keep artifacts for audits—trace files, WCET reports, and hardware model snapshots.

Getting started resources

Begin by setting up VectorCAST as your test harness and enabling the RocqStat plugin or integration provided in VectorCAST 2026+ releases. If you are a StatInf customer, expect migration guidance and continuity as Vector integrates the team and tech.

Final notes

Timing safety is not a one-off task; it is a continuous engineering discipline. The VectorCAST + RocqStat integration gives teams a practical path to making WCET and timing analysis a first-class citizen in embedded CI. Use the workflow above, automate aggressively, and keep evidence reproducible for safety audits and fast incident resolution.

Ready to put timing analysis into CI? Clone our sample repo with VectorCAST + RocqStat CI templates and an example hardware model (starter configs for GitLab CI and GitHub Actions) to kickstart your pipeline—or contact our engineering team for a hands-on walkthrough and proof-of-concept.

Call to action

Get the sample repo and CI templates: request access or schedule a demo to see VectorCAST + RocqStat in action with reproducible WCET checks in your embedded CI workflow.

Related Reading

• Turning Folk Heritage into Global Pop: Lessons from BTS Naming Their Album ‘Arirang’
• Designing Landing Pages for Social Search Discovery in 2026
• Bluesky For Gamers: How Streamers Can Use LIVE Badges and Cashtags to Grow Viewership
• Can a Wristband Replace a Thermometer for Fertility Tracking? What Shoppers Need to Know
• CES 2026: Hype vs. Helpful — Which New Gadgets Will Actually Change Your Gaming Setup?