The term shared dataspace refers to the general class of models and languages in which the principal means of communication is a common, content-addressable data structure called a dataspace. Swarm is a simple languag...
详细信息
The term shared dataspace refers to the general class of models and languages in which the principal means of communication is a common, content-addressable data structure called a dataspace. Swarm is a simple language we have used as a vehicle for the investigation of the shared dataspace approach to concurrent computation. It is the first shared dataspace language to have an associated assertional-style proof system. An important feature of Swarm is its ability to bring a variety of programming paradigms under a single, unified model. In a series of related examples we explore Swarm's capacity to express shared-variable, message-passing, and rule-based computations;to specify synchronous and asynchronous processing modes;and to accommodate highly dynamic program and data structures. Several illustrations make use of a programming construct unique to Swarm, the synchrony relation, and explain how this feature can be used to construct dynamically structured, partially synchronous computations. The paper has three parts: an overview of the Swarm programming notation, an examination of Swarm programming strategies via a series of related example programs, and a discussion of the distinctive features of the shared dataspace model. A formal operational model for Swarm is presented in the Appendix.
This paper describes a secure programming language called Joyce based on CSP and Pascal. Joyce permits unbounded (recursive) activation of communicating agents. The agents exchange messages through synchronous channel...
详细信息
This paper describes a secure programming language called Joyce based on CSP and Pascal. Joyce permits unbounded (recursive) activation of communicating agents. The agents exchange messages through synchronous channels. A channel can transfer messages of different types between two or more agents. A compiler can check message types and ensure that agents use disjoint sets of variables only. The use of Joyce is illustrated by a variety of examples.
This article evaluates the scalability and productivity of six parallel programming models for heterogeneous architectures, and finds that task-based models using code and data annotations require the minimum programm...
详细信息
This article evaluates the scalability and productivity of six parallel programming models for heterogeneous architectures, and finds that task-based models using code and data annotations require the minimum programming effort while sustaining nearly best performance. However, achieving this result requires both extensions of programming models to control locality and granularity and proper interoperability with platform-specific optimizations.
Development of embedded systems has been receiving in last decade a considerable attention for both academy and industry. Advances in hardware miniaturization, in particular, single-boards computers like Raspberry Pi,...
详细信息
ISBN:
(纸本)9781450348362
Development of embedded systems has been receiving in last decade a considerable attention for both academy and industry. Advances in hardware miniaturization, in particular, single-boards computers like Raspberry Pi, Beaglebone Black, allow for the use of high-level programming languages. Still, the greatest challenges when developing IoT applications are distribution and coordination. To date, mainstream languages (e.g. Java, JavaScript, Python) lack high- level abstractions to deal with distribution and coordination. For example, implementing standard leader election algorithms (e.g., Ring, Bully) with these languages, force developers to write code on top of low-level networking APIs. As a result, programmers need to write over and over, aspects like the discovery of peers, coordination, failure handling necessary for implementing distributed algorithms. Furthermore, craft and deploy such systems on embedded devices is also complex, due to hardware restrictions and software dependencies. In this demo, we show how a concurrent and distributed language with a rich macro system could in an easy and declarative way solve these problems. Our demo recreates a leader election algorithm between the nodes in an embedded environment by employing a Raspberry Pi cluster. The code for the leader election algorithm is built on top of a macro-based Elixir library which includes abstractions for distribution and coordination. Developers can use this library to translate core operations described by the Bully algorithm to declarative macro-constructs. This library also abstracts developers of communication and network concerns (e.g. service discovery and network monitoring). Furthermore, it includes an implementation of an Elixir behaviour (design pattern) to provide a base skeleton for developing leader-election applications.
The MapReduce programming model is widely used to parallelize data processing over the large scale of commodity computer clusters. However, on account of its monotonous data representation, it fails to express graph-p...
详细信息
The MapReduce programming model is widely used to parallelize data processing over the large scale of commodity computer clusters. However, on account of its monotonous data representation, it fails to express graph-parallel algorithms naturally and execute them efficiently. Alternatively, Pregel and PowerGraph could address these challenges. But they require users to familiarize another set of programming patterns and platforms, and at the same time the legacy MapReduce code also becomes incompatible and useless. In this paper, we proposed the Graph-compatible MapReduce (GMR) as an extension of Google's Standard MapReduce (SMR). In this way, graph-parallel algorithm will be naturally expressed without compromising the efficiency and simplicity, and meanwhile the conventional MapReduce programming pattern be preserved. Also, users could gain the convenience of Think like a vertex. Based on the experimental studying, we analyzed the ratio of the redundant computation, transmission and data caching introduced in naive iterative MapReduce platforms (e.g., HaLoop, Twister). Furthermore, we discussed the difference between GMR and the graph-targeted frameworks. The evaluation experiment results show that GMR outperforms GraphX in a series of real-world graph-parallel algorithms.
Haskell is a modern, functional programming language with an interesting story to tell about parallelism: rather than using concurrent threads and locks, Haskell offers a variety of libraries that enable concise, high...
详细信息
Haskell is a modern, functional programming language with an interesting story to tell about parallelism: rather than using concurrent threads and locks, Haskell offers a variety of libraries that enable concise, high-level parallel programs with results that are guaranteed to be deterministic (independent of the number of cores and the scheduling being used).
There is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are...
详细信息
There is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are often forced to write parts of concurrent applications in an event-driven style which obscures control flow,and increases the burden on the programmer. In this paper we show how thread-based and event-based programming can be unified under a single actor abstraction. Using advanced abstraction mechanisms of the Scala programming language, we implement our approach on unmodified JVMs. Our programming model integrates well with the threading model of the underlying VM. (C) 2008 Elsevier B.V. All rights reserved.
Concurrency and real-time constraints must be treated carefully in programming process control systems. However, most existing concepts incorporate synchronization mechanisms into communication primitives, degrading ...
详细信息
Concurrency and real-time constraints must be treated carefully in programming process control systems. However, most existing concepts incorporate synchronization mechanisms into communication primitives, degrading process independence and restricting the parallelism they are attempting to provide. Consequently, such requirements as event-driven or time-dependent execution hardly can be met. A solution has been developed that offers a set of high-level linguistic primitives based on asynchronous process communication. The approach clearly distinguishes process synchronization from process communication. As a result, concurrent behavior is expressed more loosely and process independence is substantially improved. The proposed concurrency mechanism enables continuous execution as a direct result of asynchronous process communication. It also exploits the parallelism possible in distributed hardware.
The conversation scheme has been defined to design concurrent software which provides backward error recovery. Since presently no widespread programming language provides constructs for implementing conversations, we ...
详细信息
The conversation scheme has been defined to design concurrent software which provides backward error recovery. Since presently no widespread programming language provides constructs for implementing conversations, we propose a methodology for structuring programs, following the conversation scheme. We analyze the use of conversation in languages which adopt the client-server model for processes interaction, pointing out solutions to problems arising from the use of operation and procedure oriented languages [1: Andrews and Schneider, ACM Comput. Surv. 15: 3-44;1983], in which servers are implemented as remote procedures or monitors respectively. The features of a number of programming languages, which are the most suitable for structuring conversations are pointed out. The implementation of nested conversations is also discussed and finally, an industrial application in which our methodology has been profitably applied is presented.
The fact that graphics processors (GPUs) are today's most powerful computational hardware for the dollar has motivated researchers to utilize the ubiquitous and powerful GPUs for general-purpose computing. However...
详细信息
The fact that graphics processors (GPUs) are today's most powerful computational hardware for the dollar has motivated researchers to utilize the ubiquitous and powerful GPUs for general-purpose computing. However, unlike CPUs, GPUs are optimized for processing 3D graphics (e.g., graphics rendering), a kind of data-parallel applications, and consequently, several GPUs do not support strong synchronization primitives to coordinate their cores. This prevents the GPUs from being deployed more widely for general-purpose computing. This paper aims at bridging the gap between the lack of strong synchronization primitives in the GPUs and the need for strong synchronization mechanisms in parallel applications. Based on the intrinsic features of typical GPU architectures, we construct strong synchronization objects such as wait-free and t-resilient read-modify-write objects for a general model of GPU architectures without hardware synchronization primitives such as test-and-set and compare-and-swap. Accesses to the wait-free objects have time complexity O(N), where N is the number of processes. The wait-free objects have the optimal space complexity O(N-2) . Our result demonstrates that it is possible to construct wait-free synchronization mechanisms for GPUs without strong synchronization primitives in hardware and that wait-free programming is possible for such GPUs.
暂无评论