1,466 research outputs found
Synchronous Multiparty Session Types
AbstractSynchronous communication is useful to model multiparty sessions where control for timing events and strong sequentially order of messages are essential to the problem specification. This paper continues the work on multiparty session types initiated by Honda et al. [Honda, K., N. Yoshida and M. Carbone, Multiparty asynchronous session types, in: G. C. Necula and P. Wadler, editors, POPL (2008), pp. 273–284] for synchronous communications. It provides a more relaxed syntax of the calculus, multicasting, higher-order communication via multipolarity labels and a clear definition of delegation in global types. The linearity property defines when a channel can be used in two different communications without creating a race condition and the type system checks if all the processes of a session implement the communication behavior specified in the global type. The type system of the calculus is proved to be sound with respect to the operational semantics and coherent with respect to the global types
Causal Consistency for Reversible Multiparty Protocols
In programming models with a reversible semantics, computational steps can be
undone. This paper addresses the integration of reversible semantics into
process languages for communication-centric systems equipped with behavioral
types. In prior work, we introduced a monitors-as-memories approach to
seamlessly integrate reversible semantics into a process model in which
concurrency is governed by session types (a class of behavioral types),
covering binary (two-party) protocols with synchronous communication. The
applicability and expressiveness of the binary setting, however, is limited.
Here we extend our approach, and use it to define reversible semantics for an
expressive process model that accounts for multiparty (n-party) protocols,
asynchronous communication, decoupled rollbacks, and abstraction passing. As
main result, we prove that our reversible semantics for multiparty protocols is
causally-consistent. A key technical ingredient in our developments is an
alternative reversible semantics with atomic rollbacks, which is conceptually
simple and is shown to characterize decoupled rollbacks.Comment: Extended, revised version of a PPDP'17 paper
(https://doi.org/10.1145/3131851.3131864
Session Communication and Integration
The scenario-based specification of a large distributed system is usually
naturally decomposed into various modules. The integration of specification
modules contrasts to the parallel composition of program components, and
includes various ways such as scenario concatenation, choice, and nesting. The
recent development of multiparty session types for process calculi provides
useful techniques to accommodate the protocol modularisation, by encoding
fragments of communication protocols in the usage of private channels for a
class of agents. In this paper, we extend forgoing session type theories by
enhancing the session integration mechanism. More specifically, we propose a
novel synchronous multiparty session type theory, in which sessions are
separated into the communicating and integrating levels. Communicating sessions
record the message-based communications between multiple agents, whilst
integrating sessions describe the integration of communicating ones. A
two-level session type system is developed for pi-calculus with syntactic
primitives for session establishment, and several key properties of the type
system are studied. Applying the theory to system description, we show that a
channel safety property and a session conformance property can be analysed.
Also, to improve the utility of the theory, a process slicing method is used to
help identify the violated sessions in the type checking.Comment: A short version of this paper is submitted for revie
Precise subtyping for synchronous multiparty sessions
The notion of subtyping has gained an important role both in theoretical and applicative domains: in lambda and concurrent calculi as well as in programming languages. The soundness and the completeness, together referred to as the preciseness of subtyping, can be considered from two different points of view: operational and denotational. The former preciseness has been recently developed with respect to type safety, i.e. the safe replacement of a term of a smaller type when a term of a bigger type is expected. The latter preciseness is based on the denotation of a type which is a mathematical object that describes the meaning of the type in accordance with the denotations of other expressions from the language. The result of this paper is the operational and denotational preciseness of the subtyping for a synchronous multiparty session calculus. The novelty of this paper is the introduction of characteristic global types to prove the operational completeness
Secure Multiparty Sessions with Topics
Multiparty session calculi have been recently equipped with security
requirements, in order to guarantee properties such as access control and leak
freedom. However, the proposed security requirements seem to be overly
restrictive in some cases. In particular, a party is not allowed to communicate
any kind of public information after receiving a secret information. This does
not seem justified in case the two pieces of information are totally unrelated.
The aim of the present paper is to overcome this restriction, by designing a
type discipline for a simple multiparty session calculus, which classifies
messages according to their topics and allows unrestricted sequencing of
messages on independent topics.Comment: In Proceedings PLACES 2016, arXiv:1606.0540
The Paths to Choreography Extraction
Choreographies are global descriptions of interactions among concurrent
components, most notably used in the settings of verification (e.g., Multiparty
Session Types) and synthesis of correct-by-construction software (Choreographic
Programming). They require a top-down approach: programmers first write
choreographies, and then use them to verify or synthesize their programs.
However, most existing software does not come with choreographies yet, which
prevents their application.
To attack this problem, we propose a novel methodology (called choreography
extraction) that, given a set of programs or protocol specifications,
automatically constructs a choreography that describes their behavior. The key
to our extraction is identifying a set of paths in a graph that represents the
symbolic execution of the programs of interest. Our method improves on previous
work in several directions: we can now deal with programs that are equipped
with a state and internal computation capabilities; time complexity is
dramatically better; we capture programs that are correct but not necessarily
synchronizable, i.e., they work because they exploit asynchronous
communication
Reversing Single Sessions
Session-based communication has gained a widespread acceptance in practice as
a means for developing safe communicating systems via structured interactions.
In this paper, we investigate how these structured interactions are affected by
reversibility, which provides a computational model allowing executed
interactions to be undone. In particular, we provide a systematic study of the
integration of different notions of reversibility in both binary and multiparty
single sessions. The considered forms of reversibility are: one for completely
reversing a given session with one backward step, and another for also
restoring any intermediate state of the session with either one backward step
or multiple ones. We analyse the costs of reversing a session in all these
different settings. Our results show that extending binary single sessions to
multiparty ones does not affect the reversibility machinery and its costs
Multiparty Sessions based on Proof Nets
We interpret Linear Logic Proof Nets in a term language based on Solos
calculus. The system includes a synchronisation mechanism, obtained by a
conservative extension of the logic, that enables to define non-deterministic
behaviours and multiparty sessions.Comment: In Proceedings PLACES 2014, arXiv:1406.331
Precise subtyping for asynchronous multiparty sessions
Session subtyping is a cornerstone of refinement of communicating processes: a process implementing a session type (i.e., a communication protocol) T can be safely used whenever a process implementing one of its supertypes T0 is expected, in any context, without introducing deadlocks nor other communication errors. This paper presents the first formalisation of the precise subtyping relation for asynchronous multiparty sessions: we show that the relation is sound (i.e., guarantees safe process replacement, as outlined above) and also complete: any extension of the relation is unsound. Previous work studies precise subtyping for binary sessions (with two participants), or multiparty sessions (with any number of participants) and synchronous interaction. Here, we cover multiparty sessions with asynchronous interaction, where messages are transmitted via FIFO queues (as in the TCP/IP protocol). In this setting, the subtyping relation becomes highly complex: under some conditions, participants can permute the order of their inputs and outputs, by sending some messages earlier, or receiving some later, without causing errors; the precise subtyping relation must capture all such valid permutations, and consequently, its formalisation and proofs become challenging. Our key discovery is a methdology to decompose session types into single input/output session trees, and then express the subtyping relation as a composition of refinement relations between such trees
- …