Correct synchronisation in a distributed system is a difficult. One effective approach to the problem is to employ a logical clock on the high-level design, which ensures deterministic concurrency. However, most real-time network protocols only provide the means for physical time synchronisation. Therefore, in the end, the inherent logical clock has to be compiled away and mapped to physical time, losing many of its benefits. We propose a new middleware called softtide, which aims to facilitate the implementation and deployment of systems with an inherent logical clock. The idea is to provide a global logical clock through API, as the basis for scheduling task executions and message transmissions. At the same time, maintain a relatively stable relation between the logical clock and physical time, to limit the jitters between devices. The synchronisation mechanism is inspired by a recent protocol called bittide, which features a decentralised architecture. Softtide has the following mathematical properties: (1) Logical synchrony, where the transmission delays between devices are constant in logical time. (2) Its behaviour is deterministic even in the presence of network delays, differing clock frequencies, and faults. (3) Finally, softtide is decentralised in nature, where devices can dynamically join and leave. The synchronised logical clock provided by softtide simplifies the design, compilation, and validation of real-time distributed systems. Empirically we show the real-world performance of softtide to always produce deterministic results.

Correct synchronisation a distributed system is difficult. One effective approach to the problem is to employ a logical clock on the high-level design, which ensures deterministic concurrency. However, most real-time network protocols only provide physical time synchronisation. Therefore, in the end, the inherent logical clock has to be compiled away and mapped to physical time, losing many of its benefits.

Cyber-Physical Systems (CPSs), especially those involving autonomy, need guarantees of their safety. Runtime Enforcement (RE) is a lightweight method to formally ensure that some specified properties are satisfied over the executions of the system. Hence, there is recent interest in the RE of CPS. However, existing methods are not designed to tackle specifications suitable for the hybrid dynamics of CPS. With this in mind, we develop runtime enforcement of CPS using properties defined in Signal Temporal Logic (STL).

Machine Learning (ML) models are increasingly adopted in Cyber-Physical Systems (CPS), yet monolithic architectures hinder interpretability, verification, and safety assurance. By decomposing a CPS into modular sub-models and embedding formally defined safety policies during training, we can construct systems that are correct-by-construction rather than relying on post-hoc falsification or unscalable static verification.

Runtime Enforcement (RE) is a monitoring technique aimed at correcting possibly incorrect executions w.r.t. a set of formal requirements (properties) of a system. In this paper, we consider enforcement monitoring of real-time properties. Thus, executions are modelled as timed words and specifications as timed automata. Moreover, we consider that the enforcer has the ability to delay events by storing or buffering them into its internal memory (and releasing them when the property is finally satisfied) and suppressing events when no delaying is appropriate. Practically, in an implementation, the internal memory of the enforcer is finite. In this paper, we propose a new RE paradigm for timed properties, where the memory of the enforcer is bounded/finite, to address practical applications with memory constraints and timed specifications. Bounding the memory presents a number of difficulties, e.g., how to accommodate a timed event into the memory when the memory is full, s.t., regardless of the course of action we choose to handle this situation, the behaviour of the bounded enforcer should not significantly differ from that of the unbounded enforcer. The problem of how to optimally discard events when the buffer is full is significantly more difficult in a timed environment where the progress of time affects the satisfaction or violation of a property. We define the bounded-memory RE problem for timed properties and develop a framework for regular timed properties specified as timed automata. The proposed framework is implemented in Python, and its performance is evaluated. From experiments, we discovered that the enforcer has a reasonable execution time overhead.