WCET and Timing Analysis Diagram Pack for Embedded Software Toolchains

Stop guessing when your code will run — integrate WCET and timing analysis into your verification flows now

If you build automotive embedded software, you know the frustration: unclear worst-case execution time (WCET) figures, inconsistent timing evidence across teams, and diagrams that take days to produce but still don’t show where timing verification sits inside CI/CD. The WCET and Timing Analysis Diagram Pack solves that by delivering ready-made sequence diagrams, timing charts, and CI/CD pipeline templates that map exactly where RocqStat and VectorCAST integrate into AUTOSAR and other embedded toolchains.

What you get in the pack — at a glance

• Editable sequence diagrams (PlantUML + SVG) showing interaction flows: build → unit test → VectorCAST → RocqStat → report
• Timing charts and WCET visualization templates (SVG/PNG/CSV) for per-task and global scheduling analysis
• CI/CD templates: GitLab CI, Jenkinsfile, GitHub Actions workflows that run VectorCAST and RocqStat in pipeline stages
• Sample instrumentation and measurement strategies for AUTOSAR RTE tasks and OSEK-like OS traces
• Report templates and gating rules (JSON/YAML) for automated pass/fail decisions based on WCET thresholds
• How-to guide and example datasets to reproduce diagrams end-to-end

Why this matters in 2026: Vector + RocqStat and the drive to unified timing verification

In January 2026 Vector Informatik announced it had acquired StatInf’s RocqStat technology and team and that RocqStat will be integrated into VectorCAST to create a unified environment for timing analysis and software testing. As reported by Automotive World (Jan 16, 2026), this consolidation reflects a broader 2026 trend: toolchain vendors are bundling static and dynamic timing analysis with test automation to reduce handoffs and supply traceable timing evidence for safety standards.

For embedded verification teams, the practical effect is simple: tighter toolchain integration reduces the risk that WCET estimates get lost between static analysis, unit tests, and CI gates. The diagram pack is engineered to help you operationalize that integration now — whether you run VectorCAST and RocqStat today or plan to adopt the integrated toolchain as it is released.

Assets in the downloadable pack (file map)

• sequence-vec-rocqstat.puml — PlantUML sequence diagrams (editable)
• timing-chart-taskset.svg / timing-chart-taskset.png — timing visualization for task sets
• gitlab-ci-wcet.yml — GitLab CI pipeline template
• jenkinsfile-wcet.groovy — Declarative Jenkinsfile pipeline
• github-action-wcet.yml — GitHub Actions workflow
• wcet-report-template.html — HTML report with graphs and thresholds
• autosar-instrumentation.md — instrumenting RTE tasks for measurement
• README.md — usage, customization steps, and license

How to integrate RocqStat and VectorCAST into your CI/CD — practical pipeline patterns

The recommended pipeline separates concerns while keeping timing evidence traceable. Use the following stages as a template:

1. Checkout & build — compile artifacts with your cross-toolchain (GCC, IAR, Green Hills).
2. Unit & module test — run VectorCAST-hosted unit tests (component-level tests).
3. Static analysis — run MISRA checks and static code analysis (PCLint, clang-tidy).
4. Instrumented measurement — flash kernel+app on a measurement target to collect execution traces (optional but recommended).
5. Timing analysis / WCET estimation — run RocqStat (static or combined analysis) to estimate WCET and produce formal evidence.
6. Report & gate — aggregate VectorCAST results and RocqStat outputs; apply gating rules and publish reports.

Sample GitLab CI job (trimmed for clarity)

stages:
  - build
  - test
  - analyze
  - timing
  - report

build_job:
  stage: build
  script:
    - ./toolchain/build.sh

unit_test:
  stage: test
  script:
    - vectorcast/run_tests.sh --project MyECU
  artifacts:
    paths: ["vectorcast/reports"]

ro cqstat_timing:
  stage: timing
  script:
    - rocqstat analyze --input build/output.elf --config wcet-config.json --out rocq-report.json
    - python tools/merge_reports.py vectorcast/reports rocq-report.json --out combined-report.html
  artifacts:
    paths: ["rocq-report.json", "combined-report.html"]
  when: on_success

Notes: our templates include complete variables and authentication steps for self-hosted runners and target flashing. The key is to capture both the VectorCAST test artifacts and RocqStat outputs so a downstream step can gate merges by timing criteria.

Jenkins pipeline snippet (declarative)

pipeline {
  agent any
  stages {
    stage('Build') { steps { sh './toolchain/build.sh' } }
    stage('Unit Test') { steps { sh 'vectorcast/run_tests.sh --project MyECU' } }
    stage('Timing Analysis') { steps { sh 'rocqstat analyze --input build/output.elf --config wcet.json --out rocq.json' } }
    stage('Report') { steps { sh 'python tools/merge_reports.py vectorcast/reports rocq.json --out combined.html' } }
  }
  post { always { archiveArtifacts artifacts: 'combined.html, rocq.json, vectorcast/reports/**' } }
}

Sequence diagrams: where timing analysis fits

The pack includes editable sequence diagrams that show the interplay between source control, CI runners, VectorCAST, RocqStat, target hardware, and reporting. Use these for architecture reviews and to accelerate onboarding across teams.

Below is a PlantUML example (included in the pack) that you can paste into PlantUML to generate a diagram showing a timing-analysis flow:

@startuml
participant Dev
participant Git
participant CI as "CI Runner"
participant VC as "VectorCAST"
participant RS as "RocqStat"
participant Target as "Measurement Target"
Dev -> Git: push
Git -> CI: webhook
CI -> VC: run unit tests
VC --> CI: test artifacts
CI -> Target: flash/instrument & run (optional)
Target --> CI: trace logs
CI -> RS: rocqstat analyze (elf + trace)
RS --> CI: rocq_report.json
CI -> VC: merge reports
CI --> Dev: combined-report (pass/fail)
@enduml

How teams use it: include this sequence diagram in pull-request templates and verification plans to clearly state where timing evidence is produced and consumed.

Timing charts: designing readable WCET visualizations

WCET values are only useful when shown in context. The timing-chart templates in the pack visualize:

• Per-task execution windows (min/avg/max) with jitter bands
• Deadline overlays and utilization lines
• Interference and preemption markers for multicore or mixed-criticality systems

Example best practice: show both static WCET (analysis result) and measured execution time on the same chart. The difference highlights model conservatism or missing interference modeling.

PlantUML timing snippet (trimmed)

@startuml
robust "Task A" as A
robust "Task B" as B
A is running
B is waiting
A stops
B runs
@enduml

Use the included CSV templates to feed timing data into your visualization toolchain (Matplotlib, D3, or Grafana panels). The pack also contains SVG templates you can drop into verification reports.

AUTOSAR considerations and embedded constraints

AUTOSAR systems impose specific constraints that affect WCET estimation:

• RTE dispatch semantics — task activation paths and inter-runnable communication change control-flow graphs.
• OS scheduling — preemptive fixed-priority scheduling, resource locking, and priority ceilings introduce interference patterns.
• Multicore interactions — shared buses and caches require modeling of inter-core effects or measurement-based combination strategies.

The pack includes an autosar-instrumentation.md guide showing how to capture RTE event traces, map runnables to source, and prepare inputs for RocqStat. Use static model annotations to document activation sources (timers, events, external interrupts) so that RocqStat’s analysis can correctly account for activation patterns.

Best practices and anti-patterns

• Best practice: Keep timing analysis reproducible. Check investigation scripts and RocqStat/VectorCAST configs into version control alongside code.
• Best practice: Automate report aggregation so reviewers see timing and functional test results together.
• Anti-pattern: Relying solely on measurement without static analysis — measurement misses rare-but-legal execution paths.
• Anti-pattern: Running WCET only at release — run timing checks on feature branches to avoid last-minute surprises.

Real-world example: gating an ECU task WCET

Scenario: You maintain a braking-controller ECU where a safety-critical runnable must meet a 1.2 ms deadline. Your pipeline uses VectorCAST for unit tests and RocqStat for WCET.

1. Define a gating rule: WCET(task_BrakeControl) <= 1.2 ms (90th percentile for measured runs, and static WCET <= 1.2 ms).
2. Pipeline stages run unit tests, then produce an ELF for static analysis.
3. RocqStat runs in combined mode: static control-flow analysis + measured trace-data for cache and pipeline modeling.
4. CI aggregates VectorCAST test results and RocqStat WCET. If either unit tests fail or WCET > 1.2 ms, the merge is blocked and the CI comments on the MR with details and the timing chart.

Results: teams catch dangerous timing regressions early. The pack contains a complete example MR comment template that includes the combined timing chart and a link to the failing job artifacts.

How to customize and extend the assets

Customization steps in three pragmatic actions:

1. Adapt plantuml/sequence diagrams to your repo names and tool endpoints — change CI runner names and target IDs.
2. Replace sample config files (wcet-config.json) with your target-specific processor model and memory-map definitions.
3. Configure gating thresholds in gate-rules.yml and store them per-branch (main vs release) so thresholds can be looser on feature branches.

The pack’s README includes a checklist for target profile creation (cache sizes, pipeline stages, memory layout) to speed RocqStat modeling work.

Actionable takeaways — what to do this week

• Download the diagram pack and run the included PlantUML sequence diagram through your architecture review process.
• Hook the sample GitLab/Jenkins templates into a disposable branch and run a test job that produces a VectorCAST result and an empty RocqStat analysis — confirm artifact aggregation.
• Pick one safety-critical runnable, create a WCET gating rule, and enforce it in CI on a feature branch to validate the gate behavior.

"Timing safety is becoming a critical ..." — Vector Informatik (as reported by Automotive World, Jan 16, 2026)

Trends and future predictions (2026 and beyond)

Expectation for 2026–2028:

• More integrated toolchains where static WCET, dynamic measurements, and test automation share a single evidence chain.
• Increased automation of compliance evidence for standards like ISO 26262 and emerging timing assurance guidance for software-defined vehicles.
• Rising adoption of reproducible CI pipelines that include target-in-the-loop measurement, enabling continuous timing monitoring.

The integration between RocqStat and VectorCAST is an early example of this consolidation. Your diagrams and CI templates should therefore be structured to adapt as vendors expose tighter APIs and combined reporting formats.

Download, license and next steps

The WCET and Timing Analysis Diagram Pack is available from the diagrams.us Templates and Asset Library. The pack is provided with permissive editing rights so teams can adapt diagrams and pipeline templates to their internal toolchains. Included assets are platform-agnostic (PlantUML, SVG, YAML) so you can integrate them into GitHub, GitLab, Jenkins, or enterprise CI runners.

Final checklist before you enforce WCET gates

• Confirm RocqStat model parameters match your target CPU and memory map.
• Ensure VectorCAST test artifacts are produced in a CI-consumable directory structure.
• Automate the aggregation of VectorCAST and RocqStat outputs into a single HTML report.
• Define explicit gating rules and store them in code so they are versioned.
• Run an initial pilot on a feature branch and validate the MR experience for developers.

Call to action

Download the WCET and Timing Analysis Diagram Pack from the diagrams.us Templates Library, import the PlantUML and CI templates into your repo, and run the included demo pipeline this week. If you want a hands-on walkthrough, request our free 60-minute workshop where we map your ECU build and test flow onto the sequence diagrams and configure an initial RocqStat/VectorCAST CI pipeline.

Related Reading

• Can Another Studio Save New World? Legal, Technical, and Community Roadmap to Buying a Dead MMO
• Repurposing Podcast Launches: What Ant & Dec’s New Show Teaches Music Creators About Cross-Format Promotion
• Microdramas for Family Caregivers: Short Videos to Model Boundary-Setting and Self-Care
• Will Upgrading Your Car's Tech Boost Its Resale Price? A Data-Driven Look
• Vice Media’s Reboot: What Students of Media Business Should Watch