Towards an actor-based concurrent machine model

@inproceedings{Schippers2009TowardsAA,
  title={Towards an actor-based concurrent machine model},
  author={Hans Schippers and Tom Van Cutsem and Stefan Marr and Michael Haupt and Robert Hirschfeld},
  booktitle={ICOOOLPS@ECOOP},
  year={2009}
}
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… Expand
A Graph-based Operational Semantics for a Machine Model with Actor-based Concurrency
TLDR
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). Expand
Using Actors to Build a Parallel DBMS
TLDR
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. Expand
Supporting Concurrency Abstractions in High-level Language Virtual Machines
TLDR
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. Expand
A graph-based operational semantics for context-oriented programming
TLDR
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. Expand
Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models
TLDR
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. Expand
Going Stateless in Concurrent Evolutionary Algorithms
TLDR
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. Expand
Distributed Service Programming and Interoperability
TLDR
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). Expand
Scaling in Concurrent Evolutionary Algorithms
TLDR
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. Expand
Distributed Interoperability in Heterogeneous Cloud Systems
TLDR
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. Expand
Architectural Styles for Distributed Interoperability
  • J. Delgado
  • Computer Science
  • Inf. Resour. Manag. J.
  • 2013
TLDR
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. Expand
...
1
2
...

References

SHOWING 1-10 OF 20 REFERENCES
ACTORS - a model of concurrent computation in distributed systems
  • G. Agha
  • Computer Science
  • MIT Press series in artificial intelligence
  • 1990
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. Expand
Universal Mechanisms for Concurrency
TLDR
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. Expand
A Machine Model for Aspect-Oriented Programming
TLDR
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. Expand
Java-Based DSM with Object-Level Coherence Protocol Selection
TLDR
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. Expand
An implementation substrate for languages composing modularized crosscutting concerns
TLDR
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. Expand
Context-oriented Programming
TLDR
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. Expand
Concurrency among strangers: programming in E as plan coordination
TLDR
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. Expand
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 ofExpand
A tale of two directories: implementing distributed shared objects in Java
TLDR
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. Expand
Io: a small programming language
TLDR
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. Expand
...
1
2
...