Results 1  10
of
27
Towards an Algebra of Actors
, 1996
"... We present a study of the interaction properties of objects in concurrent object oriented programming. We identify a set of basic interaction mechanisms: object identity, asynchronous message passing, implicit receive primitive, which are closed to those of the actor model. Then, we define a minimal ..."
Abstract

Cited by 13 (6 self)
 Add to MetaCart
We present a study of the interaction properties of objects in concurrent object oriented programming. We identify a set of basic interaction mechanisms: object identity, asynchronous message passing, implicit receive primitive, which are closed to those of the actor model. Then, we define a minimal algebra of actors as a basic formalism for representing the semantics of concurrent object oriented programming. Finally, we define a notion of observation equivalence between the actor terms of the algebra which has been proved to be a congruence with respect to the parallel composition operator.
Behavioural Types for a Calculus of Concurrent Objects
, 1997
"... We present a new type system for TyCO, a namepassing calculus of concurrent objects. The system captures dynamic aspects of the behaviour of objects, namely nonuniform service availability. The notion of processes without errors is loosened, demanding only weak fairness in the treatment of mess ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
We present a new type system for TyCO, a namepassing calculus of concurrent objects. The system captures dynamic aspects of the behaviour of objects, namely nonuniform service availability. The notion of processes without errors is loosened, demanding only weak fairness in the treatment of messages.
Abstract Semantics by Observable Contexts
, 2008
"... The operational behavior of interactive systems is usually given in terms of transition systems labeled with actions, which, when visible, represent both observations and interactions with the external world. The abstract semantics is given in terms of behavioral equivalences, which depend on the ac ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
The operational behavior of interactive systems is usually given in terms of transition systems labeled with actions, which, when visible, represent both observations and interactions with the external world. The abstract semantics is given in terms of behavioral equivalences, which depend on the action labels and on the amount of branching structure considered. Behavioural equivalences are often congruences with respect to the operations of the language, and this property expresses the compositionality of the abstract semantics. A simpler approach, inspired by classical formalisms like λcalculus, Petri nets, term and graph rewriting, and pioneered by the Chemical Abstract Machine [1], defines operational semantics by means of structural axioms and reaction rules. Process calculi representing complex systems, in particular those able to generate and communicate names, are often defined in this way, since structural axioms give a clear idea of the intended structure of the states while reaction rules, which are often nonconditional, give a direct account of the possible steps. Transitions caused by reaction rules, however, are not labeled, since
Symbolic semantics revisited
, 2008
"... Symbolic bisimulations were introduced as a mean to define valuepassing process calculi using smaller, possibly finite labelled transition systems, equipped with symbolic actions. Similar ideas have been used for modeling with fewer transitions the input behavior of open and asynchronous πcalculu ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
Symbolic bisimulations were introduced as a mean to define valuepassing process calculi using smaller, possibly finite labelled transition systems, equipped with symbolic actions. Similar ideas have been used for modeling with fewer transitions the input behavior of open and asynchronous πcalculus. In this paper we generalize the symbolic technique and apply the resulting theory to these two cases, rederiving existing results. We also apply our approach to a new setting, i.e. open Petri nets, with the usual result of reducing input transitions. Our theory generalizes Leifer and Milner reactive systems by adding observations.
Customization and Composition of Distributed Objects: Policy Management in Distributed Software Architectures

, 1999
"... Research in software architecture has emphasized compositional development, where the computational aspects of a system are modularly separated from communication and coordination aspects. Typically, software architectures are factored into a set of components, which encapsulate computation, and con ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
Research in software architecture has emphasized compositional development, where the computational aspects of a system are modularly separated from communication and coordination aspects. Typically, software architectures are factored into a set of components, which encapsulate computation, and connectors, which encapsulate interactions. In terms of design, development and debugging, this separation has several important advantages. In particular, by separating application code from the protocols used for interaction, software components may be independently developed and tested. Moreover, as requirements change, existing architectural elements may be modularly replaced by new elements with appropriate properties. A fundamental problem with these abstractions is their interaction with "crosscutting" architectural features such as heterogeneity, availability, and adaptability. Availability, for example, requires protocols that manipulate both communication and resources. Controlling architectural resources, however, requires access to the internal resource usage patterns of components and connectors. Unfortunately, current architectural abstractions have inflexible interfaces which obscure these patterns. This loss of information forces the implementation of such features to be hardcoded within architectural elements, eliminating many advantages of the modular approach. In this thesis, we propose a model for distributed software architectures that exposes resource access in a modular fashion. Our model extends current architectural abstractions by providing a metaarchitecture for customization. This metaarchitecture augments the functional interface of architectural elements with an operational interface for controlling resources. We also develop a formal semantic...
A stochastic semantics for BioAmbients
 IN: PARALLEL COMPUTING TECHNOLOGIES (PACT’07). VOLUME 4671 OF LNCS
, 2007
"... We consider BioAmbients, a calculus for specifying biological entities and for simulating and analysing their behaviour. We extend BioAmbients to take quantitative information into account by defining a stochastic semantics, based on a simulation stochastic algorithm, to determine the actual rate ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
We consider BioAmbients, a calculus for specifying biological entities and for simulating and analysing their behaviour. We extend BioAmbients to take quantitative information into account by defining a stochastic semantics, based on a simulation stochastic algorithm, to determine the actual rate of transitions.
Selfassembling trees
 SOS 2006
, 2006
"... RCCS is a variant of Milner's CCS where processes are allowed a controlled form of backtracking. It turns out that the RCCS reinterpretation of a CCS process is equivalent, in the sense of weak bisimilarity, to its causal transition system in CCS. This can be used to develop an efficient method for ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
RCCS is a variant of Milner's CCS where processes are allowed a controlled form of backtracking. It turns out that the RCCS reinterpretation of a CCS process is equivalent, in the sense of weak bisimilarity, to its causal transition system in CCS. This can be used to develop an efficient method for designing distributed algorithms, which we illustrate here by deriving a distributed algorithm for assembling trees. This requires solving a highly distributed consensus, and a comparison with a traditional CCSbased solution shows that the code we obtain is shorter, easier to understand, and easier to prove correct by hand, or even to verify.
Erbium: A Deterministic, Concurrent Intermediate Representation for Portable and Scalable Performance
, 2009
"... Tuning applications for multicore systems involve subtle concepts and targetdependent optimizations. New languages are being designed to express concurrency and locality without reference to a particular architecture. But compiling such abstractions into efficient code requires a portable, interme ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Tuning applications for multicore systems involve subtle concepts and targetdependent optimizations. New languages are being designed to express concurrency and locality without reference to a particular architecture. But compiling such abstractions into efficient code requires a portable, intermediate representation: this is essential for modular composition (separate compilation), for optimization frameworks independent of the source language, and for justintime compilation of bytecode languages. An intermediate representation is also essential to library and other baseline computing infrastructure developers who cannot afford the abstraction penalty of higherlevel languages. But efficiency is nothing if it ruins productivity of the few available experts. Efficiency programmers need an alternative to fragile, adhoc optimizations built upon nondeterministic primitives. This paper introduces Erbium, an intermediate representation for compilers, a lowlevel language for efficiency programmers, and a lightweight runtime implementation. It is built upon a new data structure for scalable and deterministic concurrency, called Event Recording (Er). Our work is inspired by the semantics of dataflow and synchronous languages, motivated by advanced optimizations relying on nonblocking concurrency. We provide experimental evidence of the productivity, scalability and efficiency advantages of Erbium, relying on a prototype implementation in GCC 4.3.
Minimization Algorithm for Symbolic Bisimilarity
, 2009
"... The operational semantics of interactive systems is usually described by labeled transition systems. Abstract semantics is defined in terms of bisimilarity that, in the finite case, can be computed via the wellknown partition refinement algorithm. However, the behaviour of interactive systems is in ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
The operational semantics of interactive systems is usually described by labeled transition systems. Abstract semantics is defined in terms of bisimilarity that, in the finite case, can be computed via the wellknown partition refinement algorithm. However, the behaviour of interactive systems is in many cases infinite and thus checking bisimilarity in this way is unfeasible. Symbolic semantics allows to define smaller, possibly finite, transition systems, by employing symbolic actions and avoiding some sources of infiniteness. Unfortunately, the standard partition refinement algorithm does not work with symbolic bisimilarity.
M.: Computational selfassembly
"... The object of this paper is to appreciate the computational limits inherent in the combinatorics of an applied concurrent (aka agentbased) language κ. That language is primarily meant as a visual and concise notation for biological signalling pathways. Descriptions in κ, when enriched with suitable ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
The object of this paper is to appreciate the computational limits inherent in the combinatorics of an applied concurrent (aka agentbased) language κ. That language is primarily meant as a visual and concise notation for biological signalling pathways. Descriptions in κ, when enriched with suitable kinetic information, generate simulations as continuous time Markov chains. However, κ can be studied independently of the intended application, in a purely computational fashion, and this is what we are doing here. Specifically, we define a compilation of κ into a language where interactions can involve at most two agents at a time. That compilation is generic, the blow up in the number of rules is linear in the total rule set size, and the methodology used in deriving the compilation relies on an implicit causality analysis. The correctness proof is given in details, and correctness is spelt out in terms of the existence of a specific weak bisimulation. To compensate for the binary restriction, one allows components to create unique identifiers (aka names). An interesting byproduct of the analysis is that when using acyclic rules, one sees that name creation is not needed, and κ can be fully reduced to binary form. 1