51,152 research outputs found
Type systems for distributed programs: session communication
Distributed systems are everywhere around us and guaranteeing their correctness is of paramount importance. It is natural to expect that these systems interact and communicate among them to achieve a common task.
In this work, we develop techniques based on types and type systems for the verification of correctness, consistency and safety properties related to communication in complex distributed systems. We study advanced safety properties related to communication, like deadlock or lock freedom and progress. We study session types in the pi-calculus describing distributed systems and communication-centric computation. Most importantly, we de- fine an encoding of the session pi-calculus into the standard typed pi-calculus in order to understand the expressive power of these concurrent calculi. We show how to derive in the session pi-calculus basic properties, like type safety or complex ones, like progress, by exploiting this encoding
The Buffered \pi-Calculus: A Model for Concurrent Languages
Message-passing based concurrent languages are widely used in developing
large distributed and coordination systems. This paper presents the buffered
-calculus --- a variant of the -calculus where channel names are
classified into buffered and unbuffered: communication along buffered channels
is asynchronous, and remains synchronous along unbuffered channels. We show
that the buffered -calculus can be fully simulated in the polyadic
-calculus with respect to strong bisimulation. In contrast to the
-calculus which is hard to use in practice, the new language enables easy
and clear modeling of practical concurrent languages. We encode two real-world
concurrent languages in the buffered -calculus: the (core) Go language and
the (Core) Erlang. Both encodings are fully abstract with respect to weak
bisimulations
Recursive Session Types Revisited
Session types model structured communication-based programming. In
particular, binary session types for the pi-calculus describe communication
between exactly two participants in a distributed scenario. Adding sessions to
the pi-calculus means augmenting it with type and term constructs. In a
previous paper, we tried to understand to which extent the session constructs
are more complex and expressive than the standard pi-calculus constructs. Thus,
we presented an encoding of binary session pi-calculus to the standard typed
pi-calculus by adopting linear and variant types and the continuation-passing
principle. In the present paper, we focus on recursive session types and we
present an encoding into recursive linear pi-calculus. This encoding is a
conservative extension of the former in that it preserves the results therein
obtained. Most importantly, it adopts a new treatment of the duality relation,
which in the presence of recursive types has been proven to be quite
challenging.Comment: In Proceedings BEAT 2014, arXiv:1408.556
On the Distributability of Mobile Ambients
Modern society is dependent on distributed software systems and to verify
them different modelling languages such as mobile ambients were developed. To
analyse the quality of mobile ambients as a good foundational model for
distributed computation, we analyse the level of synchronisation between
distributed components that they can express. Therefore, we rely on earlier
established synchronisation patterns. It turns out that mobile ambients are not
fully distributed, because they can express enough synchronisation to express a
synchronisation pattern called M. However, they can express strictly less
synchronisation than the standard pi-calculus. For this reason, we can show
that there is no good and distributability-preserving encoding from the
standard pi-calculus into mobile ambients and also no such encoding from mobile
ambients into the join-calculus, i.e., the expressive power of mobile ambients
is in between these languages. Finally, we discuss how these results can be
used to obtain a fully distributed variant of mobile ambients.Comment: In Proceedings EXPRESS/SOS 2018, arXiv:1808.08071. Conference version
of arXiv:1808.0159
Encapsulation and Dynamic Modularity in the Pi-Calculus
We describe a process calculus featuring high level constructs for
component-oriented programming in a distributed setting. We propose an
extension of the higher-order pi-calculus intended to capture several important
mechanisms related to component-based programming, such as dynamic update,
reconfiguration and code migration. In this paper, we are primarily concerned
with the possibility to build a distributed implementation of our calculus.
Accordingly, we define a low-level calculus, that describes how the high-level
constructs are implemented, as well as details of the data structures
manipulated at runtime. We also discuss current and future directions of
research in relation to our analysis of component-based programming
Implementing a distributed mobile calculus using the IMC framework
In the last decade, many calculi for modelling distributed mobile code have been proposed. To assess their merits and encourage use, implementations of the calculi have often been proposed. These implementations usually consist of a limited part dealing with mechanisms that are specific of the proposed calculus and of a significantly larger part handling recurrent mechanisms that are common to many calculi. Nevertheless, also the "classic" parts are often re-implemented from scratch. In this paper we show how to implement a well established representative of the family of mobile calculi, the distributed [pi]-calculus, by using a Java middleware (called IMC - Implementing Mobile Calculi) where recurrent mechanisms of distributed and mobile systems are already implemented. By means of the case study, we illustrate a methodology to accelerate the development of prototype implementations while concentrating only on the features that are specific of the calculus under consideration and relying on the common framework for all the recurrent mechanisms like network connections, code mobility, name handling, etc
pony - The occam-pi Network Environment
Although concurrency is generally perceived to be a `hard' subject, it can in fact be very simple --- provided that the underlying model is simple. The occam-pi parallel processing language provides such a simple yet powerful concurrency model that is based on CSP and the pi-calculus. This paper presents pony, the occam-pi Network Environment. occam-pi and pony provide a new, unified, concurrency model that bridges inter- and intra-processor concurrency. This enables the development of distributed applications in a transparent, dynamic and highly scalable way. The first part of this paper discusses the philosophy behind pony, explains how it is used, and gives a brief overview of its implementation. The second part evaluates pony's performance by presenting a number of benchmarks
A randomized encoding of the pi-calculus with mixed choice
International audienceWe consider the problem of encoding the pi-calculus with mixed choice into the asynchronous pi-calculus via a uniform translation while preserving a reasonable semantics. Although it has been shown that this is not possible with an exact encoding, we suggest a randomized approach using a probabilistic extension of the asynchronous pi-calculus, and we show that our solution is correct with probability 1 under any proper adversary wrt a notion of testing semantics. This result establishes the basis for a distributed and symmetric implementation of mixed choice which, differently from previous proposals in literature, does not rely on assumptions on the relative speed of processes and it is robust to attacks of proper adversaries
- …