The proceedings contain 8 papers. The topics discussed include: PASTHA - parallelizing stencil calculations in Haskell;Ypnos: declarative, parallel structured grid programming;S-Net for multi-memory multicores;compres...
ISBN:
(纸本)9781605588599
The proceedings contain 8 papers. The topics discussed include: PASTHA - parallelizing stencil calculations in Haskell;Ypnos: declarative, parallel structured grid programming;S-Net for multi-memory multicores;compress-and-conquer for optimal multicore computing;SEQUENCEL: transparency and multi-core parallelisms;efficient parallel programming in Poly/ML and Isabelle/ML;lightweight asynchrony using parasitic threads;and a parallel ASP instantiator based on DLV.
The proceedings contain 6 papers. The topics discussed include: speculative n-way barriers;the semantics of power and ARM multiprocessor machine code;low-pain, high-gain multicoreprogramming in Haskell: coordinating ...
ISBN:
(纸本)9781605584171
The proceedings contain 6 papers. The topics discussed include: speculative n-way barriers;the semantics of power and ARM multiprocessor machine code;low-pain, high-gain multicoreprogramming in Haskell: coordinating irregular symbolic computations on multicore architectures;comparing the performance of concurrent linked-list implementations in Haskell;declarativeaspects of memory management in the concurrent collections parallel programming model;and controlling chaos: on safe side-effects in data-parallel operations.
The proceedings contain 6 papers. The topics discussed include: domain specific compilation in the NVIDIA OptiX Ray tracing engine;accelerating haskell array codes with multicore GPUs;breaking the GPU programming barr...
ISBN:
(纸本)9781450304863
The proceedings contain 6 papers. The topics discussed include: domain specific compilation in the NVIDIA OptiX Ray tracing engine;accelerating haskell array codes with multicore GPUs;breaking the GPU programming barrier with the auto-parallelizing SAC compiler;simple optimizations for an applicative array language for graphics processors;computing with streams;and declarative coordination in a multicore environment: the tyranny of streams.
The proceedings contain 7 papers. The topics discussed include: a proposal for parallel self-adjusting computation;data parallel Haskell: a status report;a concurrent constraint handling rules implementation in Haskel...
详细信息
ISBN:
(纸本)1595936904
The proceedings contain 7 papers. The topics discussed include: a proposal for parallel self-adjusting computation;data parallel Haskell: a status report;a concurrent constraint handling rules implementation in Haskell with software transactional memory;SAC: off-the-shelf support for data-parallelism on multicores;cost semantics for space usage in a parallel language;Manticore: a heterogeneous parallel language;and implementing deterministic declarative concurrency using sieves.
The proceedings contain 7 papers. The topics discussed include: or-parallel prolog execution on multicores based on stack splitting;controlling loops in parallel mercury code;expressive array constructs in an embedded...
ISBN:
(纸本)9781450311175
The proceedings contain 7 papers. The topics discussed include: or-parallel prolog execution on multicores based on stack splitting;controlling loops in parallel mercury code;expressive array constructs in an embedded GPU kernel programming language;programmable data dependencies and placements;multi-DaC programming model: a variant of multi-BSP model for divide-and-conquer algorithms;compilers must speak properties, not just code - CAL: constraint aggregation language for declarative component-coordination;and sessional dataflow.
A fully automatic, compiler-driven approach to parallelisation can result in unpredictable time and space costs for compiled code. On the other hand, a fully manual approach to parallelisation can be long, tedious, pr...
详细信息
ISBN:
(纸本)9781605588599
A fully automatic, compiler-driven approach to parallelisation can result in unpredictable time and space costs for compiled code. On the other hand, a fully manual approach to parallelisation can be long, tedious, prone to errors, hard to debug, and often architecture-specific. We present a declarative domain-specific language, Ypnos, for expressing structured grid computations which encourages manual specification of causally sequential operations but then allows a simple, predictable, static analysis to generate optimised, parallel implementations. We introduce the language and provide some discussion on the theoretical aspects of the language semantics, particularly the structuring of computations around the category theoretic notion of a comonad.
S-NET is a declarative coordination language and component technology aimed at modern multi-core/many-core architectures and systems-on-chip. It builds on the concept of stream processing to structure dynamically evol...
详细信息
ISBN:
(纸本)9781605588599
S-NET is a declarative coordination language and component technology aimed at modern multi-core/many-core architectures and systems-on-chip. It builds on the concept of stream processing to structure dynamically evolving networks of communicating asynchronous components. Components themselves are implemented using a conventional language suitable for the application domain. This two-level software architecture maintains a familiar sequential development environment for large parts of an application and offers a high-level declarative approach to component coordination. In this paper we present a conservative language extension for the placement of components and component networks in a multi-memory environment, i.e. architectures that associate individual compute cores or groups thereof with private memories. We describe a novel distributed runtime system layer that complements our existing multithreaded runtime system for shared memory multicores. Particular emphasis is put on efficient management of data communication. Last not least, we present preliminary experimental data.
We propose a programming paradigm called compress-and-conquer (CC) that leads to optimal performance on multicore platforms. Given a multicore system of p cores and a problem of size n, the problem is first reduced to...
详细信息
ISBN:
(纸本)9781605588599
We propose a programming paradigm called compress-and-conquer (CC) that leads to optimal performance on multicore platforms. Given a multicore system of p cores and a problem of size n, the problem is first reduced to p smaller problems, each of which can be solved independently of the others (the compression phase). From the solutions to the p problems, a compressed version of the same problem of size O(p) is deduced and solved (the global phase). The solution to the original problem is then derived from the solution to the compressed problem together with the solutions of the smaller problems (the expansion phase). The CC paradigm reduces the complexity of multicoreprogramming by allowing the best-known sequential algorithm for a problem to be used in each of the three phases. In this paper we apply the CC paradigm to a range of problems including scan, nested scan, difference equations, banded linear systems, and linear tridiagonal systems. The performance of CC programs is analyzed, and their optimality and linear speedup are proven. Characteristics of the problem space subject to CC are formally examined, and we show that its computational power subsumes that of scan, nested scan, and mapReduce. The CC paradigm has been implemented in Haskell as a modular, higher-order function, whose constituent functions can be shared by seemingly unrelated problems. This function is compiled into low-level Haskell threads that run on a multicore machine, and performance benchmarks confirm the theoretical analysis.
暂无评论