The bondi programming language is multi-polymorphic, in that it supports four polymorphic programming styles within a small core of computation, namely a typed pattern calculus. bondi's expressive power is illustr...
详细信息
The goal of this work is to establish a simple and flexible construction method for reflective concurrent systems. In this paper, a novel method to construct a meta-level architecture for a group of actors is presente...
详细信息
Languages and technologies used to implement component-based software are not component-based, i.e. while the design phase happens in the component world, the programming phase occurs in the object-oriented world. Whe...
详细信息
ISBN:
(纸本)9781450320399
Languages and technologies used to implement component-based software are not component-based, i.e. while the design phase happens in the component world, the programming phase occurs in the object-oriented world. When an object-oriented language is used for the programming stage, then the original component-based design vanish, because component concepts like requirements and architectures are not treated explicitly. This makes it difficult to keep model and its implementation causally connected. We present a new pure reflective component-basedprogramming and modeling language where all core component concepts are treated explicitly and therefore keeping original component-design alive. The language makes it possible to model and program component-based software using the same language plus its uniform component-based meta-model and integrated reflection capabilities make the language and its applications open and flexible. Copyright 2013 acm.
The proceedings contain 16 papers. The topics discussed include: cloud PARTE: elastic complex event processing based on mobile actors;code management automation for Erlang remote actors;towards a compositional reflect...
ISBN:
(纸本)9781450326025
The proceedings contain 16 papers. The topics discussed include: cloud PARTE: elastic complex event processing based on mobile actors;code management automation for Erlang remote actors;towards a compositional reflective architecture for actor-based systems;analyzing timed Rebecca using McErlang;structured reasoning about actor systems;efficient and fully abstract routing of futures in object network overlays;tanks: multiple reader, single writer actors;semantics-preserving sharing actors;supporting many-to-many communication;native actors - a scalable software platform for distributed, heterogeneous environments;load balancing non-uniform parallel computations;and improving the performance of actor model runtime environments on multicore and many core platforms.
Over the past few years there have been several advances in distributed systems, and more recently multi-core processors. Consequently, a natural need for concurrent and parallel programming languages arises. In this ...
详细信息
ISBN:
(纸本)9781450326025
Over the past few years there have been several advances in distributed systems, and more recently multi-core processors. Consequently, a natural need for concurrent and parallel programming languages arises. In this paper, we compare some aspects of two concurrency models, Actors and Agents, using benchmarks to evaluate: (i) the communication performance on a concurrency-heavy scenario;(ii) the performance in a scenario with the presence of bottleneck and synchronization problems;and (iii) the reactivity and fairness of the models. We chose Jason, 2APL, and GOAL as the agent-oriented programming languages and Erlang, Akka, and Actor-Foundry as the actor-oriented programming languages. Overall, Erlang displayed the best performance of all languages used in this comparison, followed by Actor- Foundry, Akka, Jason, 2APL, and GOAL, in this particular order. Copyright is held by the owner/author(s).
Atomic sets are a synchronization mechanism in which the programmer specifies the groups of data that must be accessed as a unit. The compiler can check this specification for consistency, detect deadlocks, and automa...
详细信息
ISBN:
(纸本)9781450321280
Atomic sets are a synchronization mechanism in which the programmer specifies the groups of data that must be accessed as a unit. The compiler can check this specification for consistency, detect deadlocks, and automatically add the primitives to prevent interleaved access. Atomic sets relieve the programmer from the burden of recognizing and pruning execution paths which lead to interleaved access, thereby reducing the potential for data races. However, manually converting programs from lock-based synchronization to atomic sets requires reasoning about the program's concurrency structure, which can be a challenge even for small programs. Our analysis eliminates the challenge by automating the reasoning. Our implementation of the analysis allowed us to derive the atomic sets for large code bases such as the Java collections framework in a matter of minutes. The analysis is based on execution traces;assuming all traces reflect intended behavior, our analysis enables safe concurrency by preventing unobserved interleavings which may harbor latent Heisenbugs.
X10 is a HPC (High Performance Computing) programming language proposed by IBMfor supporting a PGAS (Partitioned Global Address Space) programming model offering a shared address space. The address space can be furthe...
详细信息
In distributed object systems, it is desirable to enable migration of objects between locations, e.g., in order to support efficient resource allocation. Existing approaches build complex routing infrastructures to ha...
详细信息
ISBN:
(纸本)9781450326025
In distributed object systems, it is desirable to enable migration of objects between locations, e.g., in order to support efficient resource allocation. Existing approaches build complex routing infrastructures to handle object-to-object communication, typically on top of IP, using, e.g., message forwarding chains or centralized object location servers. These solutions are costly and problematic in terms of efficiency, overhead, and correctness. We show how location independent routing can be used to implement object overlays with complex messaging behavior in a sound, fully abstract, and efficient way, on top of an abstract network of processing nodes connected point-to-point by asynchronous channels. We consider a distributed object language with futures, essentially lazy return values. Futures are challenging in this context due to the global consistency requirements they impose. The key conclusion is that execution in a decentralized, asynchronous network can preserve the standard, network-oblivious behavior of objects with futures, in the sense of contextual equivalence. To the best of our knowledge, this is the first such result in the literature. We also believe the proposed execution model may be of interest in its own right in the context of large-scale distributed computing. Copyright is held by the owner/author(s).
Declarative dataflow values are single assignment variables such that all operations needing their values wait automatically until the values are available. Adding threads and declarative dataflow values to a function...
详细信息
ISBN:
(纸本)9781450320641
Declarative dataflow values are single assignment variables such that all operations needing their values wait automatically until the values are available. Adding threads and declarative dataflow values to a functional language gives declarative concurrency, a model in which concurrency is deterministic and explicit synchronization is not needed. In our experience, this greatly simplifies the writing of concurrent programs (as explained in several chapters of CTM [20]). We complete this model with lazy execution and message-passing concurrency. Both extensions are tightly integrated with the declarative dataflow core. Lazy execution is provided by extending declarative dataflow with a by-need synchronization operation. Message passing is provided by adding streams equipped with a send operation, where a stream is a list with an unbound single-assignment variable. This paper presents the Ozma language, a conservative extension of Scala that supports all these concepts. We have made a complete implementation of Ozma by combining the implementations of Scala and Oz. Evaluation shows that this implementation supports the full semantics of Scala with concurrent programs based on the new concurrency model. In particular, within the functional subset of Scala the new concurrency model fully supports deterministic concurrency. Copyright 2013 acm.
The dataflow programming paradigm addresses how data flows inside programs. Program components, that are often concurrently active, send data to one another;this eases software composition. Mainstream programming lang...
详细信息
ISBN:
(纸本)9781450320641
The dataflow programming paradigm addresses how data flows inside programs. Program components, that are often concurrently active, send data to one another;this eases software composition. Mainstream programming languages do not support the paradigm well because of their deterministic and sequential nature. A language that focuses on concurrency is better suited to incorporate concepts from the dataflow paradigm. SubScript is an extension to the Scala programming language with constructs from the Algebra of Communicating Processes, targeted at event-driven and concurrentprogramming. Like ACP, SubScript focuses on program behavior;support for data was through local variables and parameters. However, the ACP background enabled SubScript to deal with the challenges of the dataflow paradigm. This is achieved through several new features. 1. A process may have a result value, like a method 2. A process result value may be passed on to another process that starts subsequently. This helps getting rid of variables, e.g., in GUI controller specifications. 3. Output actions from a process may be piped to a parallel process, yielding a similar expressiveness as pipes in Unix command shell language. 4. Actors written in Scala often need to keep track of a state, and their program text poorly expresses the conceptual control flow. When such actors are written in SubScript, incoming data may be treated as events that may appear anywhere in the specification, just like in SubScript GUI specifications. Copyright 2013 acm.
暂无评论