7 research outputs found
States in Process Calculi
Formal reasoning about distributed algorithms (like Consensus) typically
requires to analyze global states in a traditional state-based style. This is
in contrast to the traditional action-based reasoning of process calculi.
Nevertheless, we use domain-specific variants of the latter, as they are
convenient modeling languages in which the local code of processes can be
programmed explicitly, with the local state information usually managed via
parameter lists of process constants. However, domain-specific process calculi
are often equipped with (unlabeled) reduction semantics, building upon a rich
and convenient notion of structural congruence. Unfortunately, the price for
this convenience is that the analysis is cumbersome: the set of reachable
states is modulo structural congruence, and the processes' state information is
very hard to identify. We extract from congruence classes of reachable states
individual state-informative representatives that we supply with a proper
formal semantics. As a result, we can now freely switch between the process
calculus terms and their representatives, and we can use the stateful
representatives to perform assertional reasoning on process calculus models.Comment: In Proceedings EXPRESS/SOS 2014, arXiv:1408.127
A fault tolerance bisimulation proof for consensus
The possibility of partial failure occuring at any stage of computation complicates rigorous formal treatment of distributed algorithms. We propose a methodology for formalising and proving the correctness of distributed algorithms which alleviates this complexity. The methodology uses fault-tolerance bisimulation proof techniques to split the analysis into two phases, that is a failure-free phase and a failure phase, permitting separation of concerns. We design a minimal partial-failure calculus, develop a corresponding bisimulation theory for it and express a consensus algorithm in the calculus. We then use the consensus example and the calculus theory to demonstrate the benefits of our methodology.peer-reviewe
Fault-Tolerant Multiparty Session Types (Technical Report)
Multiparty session types are designed to abstractly capture the structure of
communication protocols and verify behavioural properties. One important such
property is progress, i.e., the absence of deadlock. Distributed algorithms
often resemble multiparty communication protocols. But proving their
properties, in particular termination that is closely related to progress, can
be elaborate. Since distributed algorithms are often designed to cope with
faults, a first step towards using session types to verify distributed
algorithms is to integrate fault-tolerance.
We extend multiparty session types to cope with system failures such as
unreliable communication and process crashes. Moreover, we augment the
semantics of processes by failure patterns that can be used to represent system
requirements (as, e.g., failure detectors). To illustrate our approach we
analyse a variant of the well-known rotating coordinator algorithm by Chandra
and Toueg. This technical report presents the proofs and some additional
material to extend [30]
Adaptable processes
We propose the concept of adaptable processes as a way of overcoming the
limitations that process calculi have for describing patterns of dynamic
process evolution. Such patterns rely on direct ways of controlling the
behavior and location of running processes, and so they are at the heart of the
adaptation capabilities present in many modern concurrent systems. Adaptable
processes have a location and are sensible to actions of dynamic update at
runtime; this allows to express a wide range of evolvability patterns for
concurrent processes. We introduce a core calculus of adaptable processes and
propose two verification problems for them: bounded and eventual adaptation.
While the former ensures that the number of consecutive erroneous states that
can be traversed during a computation is bound by some given number k, the
latter ensures that if the system enters into a state with errors then a state
without errors will be eventually reached. We study the (un)decidability of
these two problems in several variants of the calculus, which result from
considering dynamic and static topologies of adaptable processes as well as
different evolvability patterns. Rather than a specification language, our
calculus intends to be a basis for investigating the fundamental properties of
evolvable processes and for developing richer languages with evolvability
capabilities
FTMPST: Fault-Tolerant Multiparty Session Types
Multiparty session types are designed to abstractly capture the structure of
communication protocols and verify behavioural properties. One important such
property is progress, i.e., the absence of deadlock. Distributed algorithms
often resemble multiparty communication protocols. But proving their
properties, in particular termination that is closely related to progress, can
be elaborate. Since distributed algorithms are often designed to cope with
faults, a first step towards using session types to verify distributed
algorithms is to integrate fault-tolerance. We extend multiparty session types
to cope with system failures such as unreliable communication and process
crashes. Moreover, we augment the semantics of processes by failure patterns
that can be used to represent system requirements (as, e.g., failure
detectors). To illustrate our approach we analyse a variant of the well-known
rotating coordinator algorithm by Chandra and Toueg