Lightweight Time Modeling in Timed Creol

Creol is an object-oriented modeling language in which inherently concurrent objects exchange asynchronous method calls. The operational semantics of Creol is written in an actor-based style, formulated in rewriting logic. The operational semantics yields a language interpreter in the Maude system, which can be used to analyze models. Recently, Creol has been applied to the modeling of systems with radio communication, such as sensor systems. With radio communication, messages expire and, if sent simultaneously, they may collide in the air. In order to capture these and other properties of distributed systems, we extended Creol’s operational semantics with a notion of time. We exploit the framework of a language interpreter to use a lightweight notion of time, in contrast to that needed for a general purpose specification language. This paper presents a timed extension of Creol, including the semantics and the implementation strategy, and discusses its properties using an extended example. The approach can be generalized to other concurrent object or actor-based systems.

💡 Research Summary

The paper presents a lightweight timed extension of Creol, an object‑oriented modeling language whose operational semantics is defined in an actor‑style rewriting logic and executed in the Maude system. Creol excels at describing inherently concurrent objects that communicate via asynchronous method calls, but its original semantics lacks any notion of physical time, which is essential for modeling distributed systems that rely on radio communication. In such systems messages have a limited lifetime and simultaneous transmissions may collide, phenomena that cannot be captured by a purely logical, instantaneous semantics.

To address this gap the authors introduce “Timed Creol”. The extension adds a single global clock variable, now, that is shared by all objects. Time advances only through explicit rewrite rules, preserving the simplicity of Creol’s original semantics while providing enough structure to model real‑time behavior. Two new kinds of rules are defined: a “tick” rule that increments the global clock when no other event is enabled, and a “time‑pass” rule that allows an object to remain idle while time progresses.

Message structures are enriched with a deadline (TTL) field. When the global clock exceeds a message’s deadline, the message is automatically removed, modeling expiration. Collision handling is realized by grouping all messages scheduled for the same time slot on the same communication channel; if more than one message appears, a collision flag is set and the receiving object can react (e.g., by retransmission or error handling). Both expiration and collision detection are expressed as conditional rewrite rules in Maude, requiring only a modest addition to the existing Creol modules.

Implementation-wise, the authors create a separate “Time” module in Maude and compose it with the original Creol module. Existing object definitions, method bodies, and the asynchronous call mechanism remain unchanged; the timed extension merely adds the clock variable, the tick rule, and the extra fields to messages. This modular approach enables users to take an existing Creol model and obtain a timed version with minimal code changes.

The paper validates the approach with an extended example: a wireless sensor network. Sensor nodes periodically generate data and broadcast it to a central hub. Each broadcast carries a TTL, and simultaneous broadcasts cause collisions. By running simulations in Maude, the authors show how varying TTL values influences message loss rates and how a simple random back‑off strategy reduces collisions and improves delivery success. Moreover, they employ Maude’s LTL model‑checking facilities to verify a real‑time safety property—“every data item reaches the hub within at most five time units”—demonstrating that the timed semantics supports formal verification of temporal properties.

In the related‑work discussion, the authors compare Timed Creol with Timed Automata, Real‑Time Maude, and other actor‑based languages that incorporate time. Unlike those approaches, Timed Creol keeps the time model lightweight: a single global clock and a deterministic tick rule avoid the state‑space explosion often associated with dense time domains, yet still capture essential radio‑communication characteristics such as message expiry and collisions.

The conclusion emphasizes that the lightweight timed extension significantly broadens Creol’s applicability to realistic distributed systems while preserving its original simplicity and tool support. The authors suggest future directions including support for multiple clocks (e.g., per‑node local time), priority‑based time‑aware events, and scalability studies on larger networks. Overall, the work demonstrates that a modest, well‑integrated notion of time can turn an already powerful concurrent modeling language into a practical platform for analyzing time‑critical, message‑driven systems.