Towards an actor-based concurrent machine model

  title={Towards an actor-based concurrent machine model},
  author={Hans Schippers and Tom Van Cutsem and Stefan Marr and Michael Haupt and Robert Hirschfeld},
In this position paper we propose to extend an existing delegation-based machine model with concurrency primitives. The original machine model which is built on the concepts of objects, messages, and delegation, provides support for languages enabling multi-dimensional separation of concerns (MDSOC). We propose to extend this model with an actor-based concurrency model, allowing for both true parallelism as well as lightweight concurrency primitives such as coroutines. In order to demonstrate… 

Figures from this paper

A Graph-based Operational Semantics for a Machine Model with Actor-based Concurrency

This paper adds concurrency primitives based on the wellknown actor model of computation and specifies an operational semantics for this extended machine model using graph rewrite rules to provide support for multidimensional separation of concerns (MDSOC).

Using Actors to Build a Parallel DBMS

A nested transaction model is proposed and used to handle concurrency access and recovery and a novel approach is proposed, based on wait-die, to implement a distributed deadlock prevention technique for the model of nested transactions.

Supporting Concurrency Abstractions in High-level Language Virtual Machines

The OMOP proposed in this dissertation provides a unifying and minimal substrate to support concurrent programming on top of multi-language VMs, enabling language implementers to correctly implement language semantics, while simultaneously enabling VMs to provide efficient implementations.

A graph-based operational semantics for context-oriented programming

A graph- based semantics for context-oriented programming built on top of a concurrent actor-based semantics of delMDSOC is introduced, which allows for the visual simulation of context- oriented programs, which is demonstrated by means of an example.

Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models

The goal is to develop a methodology to design instruction sets with concurrency support in VMs and to propose a list of trade-offs that have to be investigated to advise the design of such instruction sets.

Going Stateless in Concurrent Evolutionary Algorithms

Different versions of these stateless, reactive architectures applied to evolutionary algorithms are analyzed, assessing how they interact with the characteristics of the evolutionary algorithm itself and show how they improve the scaling behavior and performance.

Distributed Service Programming and Interoperability

This chapter proposes one single language to support several levels that are currently implemented in separate technologies: data, interface, and behavior (usually done in BPEL or in a general programming language).

Scaling in Concurrent Evolutionary Algorithms

The results indicate that concurrency is advantageous to scale-up the performance of evolutionary algorithms and highlight how the trade–off between concurrency, communication and evolutionary parameters affect the outcome of the evolved solutions, opening-up new opportunities for algorithm design.

Distributed Interoperability in Heterogeneous Cloud Systems

This chapter details the interoperability problem and presents an interoperability framework, which provides a systematization of aspects such as coupling, compatibility, and the various levels at which interoperability must occur, and proposes an alternative technology.

Architectural Styles for Distributed Interoperability

  • J. Delgado
  • Computer Science
    Inf. Resour. Manag. J.
  • 2013
An architectural style, Structural Service, capable of combining resource structure with flexible services, and a distributed interoperability mechanism, based on structural compliance and conformance, which supports partial interoperability and reduces coupling between interacting services while ensuring that the interoperability requirements of the application are satisfied.



ACTORS - a model of concurrent computation in distributed systems

  • G. Agha
  • Computer Science
    MIT Press series in artificial intelligence
  • 1985
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.

Universal Mechanisms for Concurrency

A machine model consisting of a set of primitive mechanisms for communication, synchronization, and naming, selected as a compromise between what can easily be implemented in hardware and what is required to support parallel models of computation is proposed.

A Machine Model for Aspect-Oriented Programming

This paper introduces a lightweight, objectbased machine model for aspect-oriented languages based on objectoriented ones that is centered around delegation and relies on a very dynamic notion of join points as loci of late-bound dispatch of functionality.

Java-Based DSM with Object-Level Coherence Protocol Selection

It is demonstrated that a multiple-writer protocol that is added to the Aleph Toolkit outperforms existing Aleph protocols for some applications, and that a combination of protocols can provide performance superior to that resulting from the use of a single coherence scheme.

An implementation substrate for languages composing modularized crosscutting concerns

Several programming languages with support for multi-dimensional separation of concerns (MDSOC) on top of a common delegation-based substrate, which is a prototype for a dedicated MDSOC virtual machine are presented.

Context-oriented Programming

This paper lays the foundations of COP, shows how dynamic layer activation enables multi-dimensional dispatch, illustrates the application of COP by examples in several language extensions, and demonstrates that COP is largely independent of other commitments to programming style.

Concurrency among strangers: programming in E as plan coordination

This paper shows how hard it is to use locking to prevent plans from interfering without also destroying their ability to cooperate, and explains how the E language addresses these joint challenges by changing only a few concepts of conventional sequential object programming.

Programming dynamically reconfigurable open systems with SALSA

Applications running on the Internet, or on limited-resource devices, need to be able to adapt to changes in their execution environment at run-time. Current languages and systems fall short of

A tale of two directories: implementing distributed shared objects in Java

This paper describes the experience implementing two distributed directory protocols as part of the Aleph tool& a distributed shared object system implement, and is surprised to discover that the arrow protocol outperformed the home protocol, sometimes substantially, across a range of system sizes.

Io: a small programming language

An overview of the Io language and demos of some multi-platform desktop applications written with it are included, well suited for use as both scripting and embedding within larger projects.