Programming dynamically reconfigurable open systems with SALSA

@article{Varela2001ProgrammingDR,
  title={Programming dynamically reconfigurable open systems with SALSA},
  author={Carlos A. Varela and G. Agha},
  journal={ACM SIGPLAN Notices},
  year={2001},
  volume={36},
  pages={20-34}
}
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 enabling developers to migrate and reconfigure application sub-components at program-execution time.In this paper, we describe essential aspects of the design and implementation of SALSA, an actor-based language for mobile and Internet computing. SALSA simplifies programming dynamically reconfigurable… Expand
A Distributed Selectors Runtime System for Java Applications
TLDR
This paper focuses on the Selector Model (a generalization of the actor model) as a foundation for creating distributed programs and introduces a unified runtime system that supports both shared memory and distributed multi-node execution of such programs. Expand
A Programming Model and Language for Concurrent and Distributed Object-Oriented Systems
TLDR
The thesis at hand presents a formalization of the semantics of the cobox model in a core calculus, which is proved type-sound and several additional properties are formally covered. Expand
Performance tuning for actor programs through decoupled concurrency
TLDR
This work proposes a new parallel programming paradigm which separates programs’ concurrency from their functionality code, harnessing the notable programmability of the Actor model, and develops two tuning policies which can be dynamically tuned at run-time based on predefined tuning policies, which are programmable and reusable. Expand
Parallel Programming in Actor-Based Applications via OpenCL
TLDR
This paper presents an extension to an existing actor-based programming model and runtime to support executing applications on parallel hardware architectures, and shows thatActor-based kernels are always significantly simpler than API-based coding, and generally simpler than pragma- based coding. Expand
Native actors: a scalable software platform for distributed, heterogeneous environments
TLDR
Thorough performance evaluations reveal an extraordinary small memory footprint in realistic application scenarios, while runtime performance not only outperforms existing mature actor implementations, but exceeds the scaling behavior of low-level message passing libraries such as OpenMPI. Expand
State Exploration of Scala Actor Programs
TLDR
This dissertation developed a general framework, called SEJAP, for exploring possible message schedules in actor systems compiled to the Java bytecode, and implemented the framework, Scala instantiation, and optimizations in Java PathFinder, a widely used model checker for Javabytecode developed by NASA. Expand
libcppa - Designing an Actor Semantic for C++11
TLDR
With the open source library libcppa, the ability to build reliable and distributed systems provided by the actor model with the performance and resource-efficiency of C++11 is combined. Expand
The DSystemJ programming language for dynamic GALS systems: it's semantics, compilation, implementation, and run-time system
TLDR
DSystemJ offers very safe mechanisms for implementation of dynamic distributed systems and potential for their formal verification, and the principles and details of DSystemJ's compilation, as well as its required runtime support are described. Expand
Formal Semantics, Compilation and Execution of the GALS Programming Language DSystemJ
TLDR
DSystemJ is presented, which allows the creation and control at runtime of asynchronous processes called clock-domains, their mobility on a distributed execution platform, as well as the runtime reconfiguration of the system's functionality and topology. Expand
Isolated Actors for Race-Free Concurrent Programming
TLDR
A novel way to support internal aliasing of unique references leads to a surprisingly simple type system which allows type checking real-world Scala code with only few changes and shows that the type system can be integrated into full-featured languages. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 50 REFERENCES
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. Expand
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
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. Expand
HAL: A High-Level Actor Language and Its Distributed Implementation
TLDR
This paper describes the design of Hal, an architecture independent, concurrent object-oriented language which supports inheritance, synchronization constraints, continuation capture, synchronous and asynchronous message passing, and re ection. Expand
MultiJava: modular open classes and symmetric multiple dispatch for Java
TLDR
MultiJava is presented, a backward-compatible extension to Java supporting open classes and symmetric multiple dispatch, and adapt previous theoretical work to allow compilation units to be statically typechecked modularly and safely, ruling out any link-time or run-time type errors. Expand
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. Expand
Abstracting Interaction Patterns: A Programming Paradigm for Open Distributed Systems
TLDR
This paper discusses mechanisms addressing the complexity of building and maintaining Open Distributed Systems and defines actors as a model of concurrency for open systems, and reviews a number of programming abstractions that are useful in modular specification and implementation of open systems. Expand
Concurrent Aggregates: Supporting Modularity in Massively Parallel Programs
TLDR
Concurrent Aggregates describes a novel approach for managing program complexity, based on multi-access data abstractions and combining ideas from object-oriented and data-parallel approaches, that allows programmers to build modular programs without sacrificing concurrency. Expand
Escape analysis for Java
TLDR
A new program abstraction for escape analysis, the connection graph, that is used to establish reachability relationships between objects and object references is introduced and it is shown that the connectiongraph can be summarized for each method such that the same summary information may be used effectively in different calling contexts. Expand
Guava: a dialect of Java without data races
TLDR
Guava is introduced, a dialect of Java whose rules statically guarantee that parallel threads access shared data only through synchronized methods, and how implementations of Guava can exploit these rules to re-enable compiler optimizations inhibited by standard Java. Expand
...
1
2
3
4
5
...