24 research outputs found
Reversibility and asymmetric conflict in event structures
Reversible computation has attracted increasing interest in recent years, with applications in hardware, software and biochemistry. We introduce reversible forms of prime event structures and asymmetric event structures. In order to control the manner in which events are reversed, we use asymmetric conflict on events. We prove a number of results about reachable configurations; for instance, we show under what conditions reachable configurations which are finite are reachable by purely finite means. We discuss, with examples, reversing in causal order, where an event is only reversed once all events it caused have been reversed, as well as forms of non-causal reversing
Causal Reversibility in Individual Token Interpretation of Petri Nets
Causal reversibility in concurrent systems means that events that the origin of other events can only be undone after undoing of its consequences. In opposite to backtracking, the events which are independent of each other can be reversed in an arbitrary order, in the other words, we have flexible reversibility w.r.t the causality relation. An implementation of Individual token interpretation ofPetri Nets (IPNs) was been proposed by Rob Van Glabbeek et al, the present paper investigates into a study of causal reversibility within IPNs. Given N be an IPN, by adding an intuitive firing rule to undo transitions according to the causality relation, the coherence of N is assured, i.e., the set of all reachable states of N in the reversible version and that of the original one are identical. Furthermore, reversibility in N is flexible and their initial state can be accessible in reverse from any state. In this paper an approach for controllingcausal-reversibility within IPNs is proposed
Comparative Transition System Semantics for Cause-Respecting Reversible Prime Event Structures
Reversible computing is a new paradigm that has emerged recently and extends
the traditional forwards-only computing mode with the ability to execute in
backwards, so that computation can run in reverse as easily as in forward. Two
approaches to developing transition system (automaton-like) semantics for event
structure models are distinguished in the literature. In the first case, states
are considered as configurations (sets of already executed events), and
transitions between states are built by starting from the initial configuration
and repeatedly adding executable events. In the second approach, states are
understood as residuals (model fragments that have not yet been executed), and
transitions are constructed by starting from the given event structure as the
initial state and deleting already executed (and conflicting) parts thereof
during execution. The present paper focuses on an investigation of how the two
approaches are interrelated for the model of prime event structures extended
with cause-respecting reversibility. The bisimilarity of the resulting
transition systems is proved, taking into account step semantics of the model
under consideration.Comment: In Proceedings AFL 2023, arXiv:2309.0112
Event structure semantics of (controlled) reversible CCS
CCSK is a reversible form of CCS which is causal, meaning that ac- tions can be reversed if and only if each action caused by them has already been reversed; there is no control on whether or when a computation reverses. We pro- pose an event structure semantics for CCSK. For this purpose we define a cat- egory of reversible bundle event structures, and use the causal subcategory to model CCSK. We then modify CCSK to control the reversibility with a rollback primitive, which reverses a specific action and all actions caused by it. To define the event structure semantics of rollback, we change our reversible bundle event structures by making the conflict relation asymmetric rather than symmetric, and we exploit their capacity for non-causal reversibility
Event structures for the reversible early internal pi-calculus
The pi-calculus is a widely used process calculus, which models com-munications between processes and allows the passing of communication links.Various operational semantics of the pi-calculus have been proposed, which canbe classified according to whether transitions are unlabelled (so-called reductions)or labelled. With labelled transitions, we can distinguish early and late semantics.The early version allows a process to receive names it already knows from the en-vironment, while the late semantics and reduction semantics do not. All existingreversible versions of the pi-calculus use reduction or late semantics, despite theearly semantics of the (forward-only) pi-calculus being more widely used than thelate. We define piIH, the first reversible early pi-calculus, and give it a denotationalsemantics in terms of reversible bundle event structures. The new calculus is a re-versible form of the internal pi-calculus, which is a subset of the pi-calculus whereevery link sent by an output is private, yielding greater symmetry between inputsand outputs
CRIL: A Concurrent Reversible Intermediate Language
We present a reversible intermediate language with concurrency for
translating a high-level concurrent programming language to another lower-level
concurrent programming language, keeping reversibility. Intermediate languages
are commonly used in compiling a source program to an object code program
closer to the machine code, where an intermediate language enables behavioral
analysis and optimization to be decomposed in steps. We propose CRIL
(Concurrent Reversible Intermediate Language) as an extension of RIL used by
Mogensen for a functional reversible language, incorporating a multi-thread
process invocation and the synchronization primitives based on the P-V
operations. We show that the operational semantics of CRIL enjoy the properties
of reversibility, including the causal safety and causal liveness proposed by
Lanese et al., checking the axiomatic properties. The operational semantics is
defined by composing the bidirectional control flow with the dependency
information on updating the memory, called annotation DAG. We show a simple
example of `airline ticketing' to illustrate how CRIL preserves the causality
for reversibility in imperative programs with concurrency.Comment: In Proceedings EXPRESS/SOS2023, arXiv:2309.0578