• Corpus ID: 202302

Actors: a model for reasoning about open distributed systems

@inproceedings{Agha2001ActorsAM,
  title={Actors: a model for reasoning about open distributed systems},
  author={Gul A. Agha and Prasanna Thati and Reza Ziaei},
  booktitle={FME 2001},
  year={2001}
}
Open distributed systems are often subject to dynamic change of hardware or software components, for example, in response to changing requirements, hardware faults, software failures, or the need to upgrade some component. In other words, open systems are reconngurable and extensible: they may allow components to be dynamically replaced or be connected with new components while they are still executing. The Actor theory we describe in this paper abstracts some fundamental aspects of open… 
Monitoring distributed systems with distributed polyLarva
TLDR
DistPolyLarva is presented, a prototype implementation of the distributed Poly Larva tool, which implements the new actor-based semantics over a language that can natively handle distribution and concurrency called Erlang.
Rebeca: Theory, Applications, and Tools
TLDR
Theories, applications, and supporting tools of Rebeca are presented in a consistent and distilled form to present the gap between formal verification approaches and real applications.
Automated Veri.cation of the Dependability of Object-Oriented Real-Time Systems
TLDR
This work achieves the goal of automatically verifying the dependability and timing properties of the target system by implementing the operational semantics of Actor and RTSynchronizer in Real-Time Maude, which supports executable specification and various temporal model checking analysis.
Model Feasible Interactions in Distributed Real-Time Systems
TLDR
It is shown that a lattice of bundled interaction diagrams can be derived from a given timed interaction diagram to improve the efficiency of feasibility checking for arbitrary real-time constraints.
Coordination operators and their composition under the actor-role-coordinator (ARC) model
TLDR
This paper defines two primitive coordination operators, i.e., precede (&cupre;t) and select (⊵p), and uses them to express temporal and spacial coordination constraints among concurrent and autonomous actors.
Limitations in AUML's Roles Specification
TLDR
This paper focuses on the limitations of the current AUML specifications and its related implications on dynamic roles.
On Actors and the REST
TLDR
The relationship between RESTful web services and the actor model of computation is investigated and it is suggested that by formulating RESTful services as a network of actors the authors can achieve deeper understanding of what it means to be RESTful.
Non-Alternating ActorGame: Game semantics for actors without alternation
  • G. Dai, Yong Wang
  • Computer Science, Political Science
    2013 IEEE International Conference on Information and Automation (ICIA)
  • 2013
TLDR
This work removes the assumption of an immediate acknowledgement to a received message for an actor in ActorGames, which makes ActorGames play without alternation and a new kind of game semantics called Non-Alternating ActorGames are introduced.
ActorGame: Game Semantics for Actors
  • Yong Wang, G. Dai
  • Computer Science
    2013 Fourth Global Congress on Intelligent Systems
  • 2013
TLDR
Game semantics model (exactly asynchronous game) is introduced into the actors which is called Actor Game, and the characteristics of actor computation model, such as receiving messages, sending messages and creating new actors, are well interpreted.
...
...

References

SHOWING 1-10 OF 53 REFERENCES
ACTORS - a model of concurrent computation in distributed systems
  • G. Agha
  • Computer Science
    MIT Press series in artificial intelligence
  • 1985
TLDR
A foundational model of concurrency is developed and issues in the design of parallel systems and why the actor model is suitable for exploiting large-scale parallelism are addressed.
THAL: An Actor System For Efficient and Scalable Concurrent Computing
TLDR
Experiments on a stock-hardware distributed memory multicomputer (CM-5) show that the compiler and the runtime system yield efficiency and scalability on applications with sufficiently large granularity which are comparable to the performance of other less flexible systems.
Modular specification of interaction policies in distributed computing
TLDR
It is demonstrated that meta-level specification of interaction policies enables modular description of component interaction policies, as well as customization of policy implementations, in the high-level language D scIL.
Interaction Semantics for Components of Distributed Systems
TLDR
A notion of abstract actor structure (AAS) is introduced that characterizes the minimal semantic requirements for an actor language and allows for components to be defined using multiple languages.
Reasoning about meta level activities in open distributed systems
TLDR
This paper considers remote creation, migration, and reachability y snapshot services: their specification at different levels of abstraction, and their composition.
Rosette: An object-oriented concurrent systems architecture
TLDR
The Rosette project at MCC is developing a system architecture for general-purpose concurrent computation based on the Actor model, which will allow the programmer to integrate high-level algorithms within the application for dividing resources dynamically among the sub-computations that are spawned.
Customization and composition of distributed objects: middleware abstractions for policy management
TLDR
The Distributed Connection Language (dcl) is described: an architecture description language based on the Actor model of distributed objects that allows system components and the policies which govern an architecture to be specified as encapsulated groups of actors.
An Actor-Based Framework for Real-Time Coordination
TLDR
The operational semantics based on RTsynchronizers and regular computational objects (modeled as actors) is defined and an algorithm for detecting infeasible real-time coordination constraints at source code level is developed.
Concurrent object-oriented programming
TLDR
The actor model as a framework for concurrent systems1 and some concepts which are useful in building actor systems are discussed and some common patterns of concurrent problem solving are outlined.
Efficient Support of Location Transparency in Concurrent Object-Oriented Programming Languages
TLDR
This work describes the design of a runtime system for a fine-grained concurrent object-oriented (actor) language and its performance and suggests that the efficiency that is lost by the greater flexibility of actors can be restored by an efficient runtime system which provides an open interface that can be used by a compiler to allow optimizations.
...
...