Performance Evaluation of Components Using a Granularity-based Interface Between Real-Time Calculus and Timed Automata

To analyze complex and heterogeneous real-time embedded systems, recent works have proposed interface techniques between real-time calculus (RTC) and timed automata (TA), in order to take advantage of the strengths of each technique for analyzing various components. But the time to analyze a state-based component modeled by TA may be prohibitively high, due to the state space explosion problem. In this paper, we propose a framework of granularity-based interfacing to speed up the analysis of a TA modeled component. First, we abstract fine models to work with event streams at coarse granularity. We perform analysis of the component at multiple coarse granularities and then based on RTC theory, we derive lower and upper bounds on arrival patterns of the fine output streams using the causality closure algorithm. Our framework can help to achieve tradeoffs between precision and analysis time.

💡 Research Summary

The paper addresses a fundamental scalability problem that arises when combining Real‑Time Calculus (RTC) with Timed Automata (TA) for the performance analysis of heterogeneous real‑time embedded systems. RTC excels at providing quick, compositional bounds on event arrival and service curves, but it lacks the expressive power to model detailed state‑based behavior such as buffers, preemptive scheduling, and complex synchronization. TA, on the other hand, can capture these intricate dynamics precisely, yet its state‑space grows exponentially with the number of events, making exhaustive analysis often infeasible for realistic components.

To bridge this gap, the authors propose a “granularity‑based interface” that abstracts fine‑grained event streams into coarser‑grained ones before feeding them to the TA model. The key steps of the methodology are:

1. Granularity Mapping – A fine‑grained stream (e.g., 1 ms events) is partitioned into blocks of k consecutive events, each block becoming a single coarse event. The mapping guarantees that each coarse event represents at least k and at most k fine events, thereby introducing a controlled over‑ and under‑approximation.

2. Coarse‑Grained TA Construction – The original TA is rewritten to operate on coarse events. Timers are scaled by k, counters are reduced accordingly, and guard conditions are rewritten in terms of the number of coarse events rather than individual fine events. This transformation shrinks the reachable state space roughly by a factor of k, mitigating the state‑space explosion.

3. Multi‑Granularity Analysis – Several granularity levels (e.g., k = 5 ms, 10 ms, 20 ms) are selected independently. For each level, the TA is analyzed using standard model‑checking tools (UPPAAL‑CORA, RTaW‑P, etc.). The analysis yields, for each granularity, an input arrival curve and an output arrival curve that bound the behavior of the component at that coarse resolution.

4. Causality Closure – Leveraging RTC theory, the authors apply a causality‑closure algorithm to the set of coarse‑grained bounds. The algorithm enforces the logical implication “if the input satisfies its upper bound, then the output must satisfy its upper bound” across all granularity levels. By intersecting the results, the algorithm derives the tightest possible fine‑grained arrival and service curves:
   \