250 research outputs found
Fifty years of Hoare's Logic
We present a history of Hoare's logic.Comment: 79 pages. To appear in Formal Aspects of Computin
Timed Actors and Their Formal Verification
In this paper we review the actor-based language, Timed Rebeca, with a focus
on its formal semantics and formal verification techniques. Timed Rebeca can be
used to model systems consisting of encapsulated components which communicate
by asynchronous message passing. Messages are put in the message buffer of the
receiver actor and can be seen as events. Components react to these
messages/events and execute the corresponding message/event handler. Real-time
features, like computation delay, network delay and periodic behavior, can be
modeled in the language. We explain how both Floating-Time Transition System
(FTTS) and common Timed Transition System (TTS) can be used as the semantics of
such models and the basis for model checking. We use FTTS when we are
interested in event-based properties, and it helps in state space reduction.
For checking the properties based on the value of variables at certain point in
time, we use the TTS semantics. The model checking toolset supports
schedulability analysis, deadlock and queue-overflow check, and assertion based
verification of Timed Rebeca models. TCTL model checking based on TTS is also
possible but is not integrated in the tool.Comment: In Proceedings EXPRESS/SOS2023, arXiv:2309.0578
Treo: Textual Syntax for Reo Connectors
Reo is an interaction-centric model of concurrency for compositional
specification of communication and coordination protocols. Formal verification
tools exist to ensure correctness and compliance of protocols specified in Reo,
which can readily be (re)used in different applications, or composed into more
complex protocols. Recent benchmarks show that compiling such high-level Reo
specifications produces executable code that can compete with or even beat the
performance of hand-crafted programs written in languages such as C or Java
using conventional concurrency constructs.
The original declarative graphical syntax of Reo does not support intuitive
constructs for parameter passing, iteration, recursion, or conditional
specification. This shortcoming hinders Reo's uptake in large-scale practical
applications. Although a number of Reo-inspired syntax alternatives have
appeared in the past, none of them follows the primary design principles of
Reo: a) declarative specification; b) all channel types and their sorts are
user-defined; and c) channels compose via shared nodes. In this paper, we offer
a textual syntax for Reo that respects these principles and supports flexible
parameter passing, iteration, recursion, and conditional specification. In
on-going work, we use this textual syntax to compile Reo into target languages
such as Java, Promela, and Maude.Comment: In Proceedings MeTRiD 2018, arXiv:1806.0933
Human-in-the-loop simulation of Cloud services
In this paper we discuss an integrated tool suite for the simulation of software services which are offered on the Cloud. The tool suite uses the Abstract Behavioral Specification (ABS) language for modeling the software services and their Cloud deployment. For the real-time execution of the ABS models we use a Haskell backend which is based on a source-to-source translation of ABS into Haskell. The tool suite then allows Cloud engineers to interact in real-time with the execution of the model by deploying and managing service instances. The resulting human-in-the-loop simulation of Cloud services can be used both for training purposes and for the (semi-)automated support for the real-time monitoring and management of the actual service instances
Guess Who\u2019s Coming: Runtime Inclusion of Participants in Choreographies
In Choreographic Programming, a choreography specifies in a single artefact the expected behaviour of all the participants in a distributed system. The choreography is used to synthesise correct-by-construction programs for each participant. In previous work, we defined Dynamic Choreographies to support the update of distributed systems at runtime. In this work, we extend Dynamic Choreographies to include new participants at runtime, capturing those use cases where the system might be updated to interact with new, unforeseen stakeholders. We formalise our extension, prove its correctness, and present an implementation in the AIOCJ choreographic framework
Eliminating opportunism using an epistemic mechanism
Opportunism is a behavior that takes advantage of knowledge asymmetry and results in promoting agents' own value and demoting other agents' value. It is important to eliminate such a selfish behavior in multi-agent systems, as it has undesirable results for the participating agents. However, as the context we study here is multi-agent systems, system designers actually might not be aware of the value system for each agent thus they have no idea whether an agent will perform opportunistic behavior. Given this fact, this paper designs an epistemic mechanism to eliminate opportunism given a set of possible value systems for the participating agents: An agent's knowledge gets updated so that the other agent is not able to perform opportunistic behavior, and there exists a balance between eliminating opportunism and respecting agents' privacy
- …