Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 4,232 papers for “data-parallel languages”

Embedded Languages for Data-Parallel Programming

Joel Svensson · Chalmers Publication Library (Chalmers University of Technology) · 2013

Computers today are becoming more and more parallel. General purpose processors (CPUs) have multiple processing cores and Single Instruction Multiple Data (SIMD) units for data-parallelism. Graphics processors (GPUs) bring massive parallelism at the cost of being harder to program than CPUs. This thesis applies embedded language methodology to data-parallel programming. Two embedded languages are presented, Obsidian for general purpose GPU programming and EmbArBB for data-parallel programming across platforms. CPUs and GPUs get more parallel resources with each new generation. The question of how to efficiently program these processors arises. We are after efficiency both in programmer productivity and in application performance. Using embedded languages allows us to experimentwith what abstractions to present to the programmer at relatively little effort.Obsidian is an embedded language for general purpose programming of GPUs. We try to strike a balance between high level, productivity increasing abstractions and low-level control needed for performance. The Obsidian programming model mirrors the GPU architecture and the programmer is constrained into writing GPU-friendly code. Hierarchy level polymorphic library functions are supplied to make these constraints feel less obtrusive. Obsidian programs are compiled into CUDA C code. This compilation is based on a simple and elegant monad reification technique. In cases where the programmer is not interested in low-level details or wants the program to run over a range of hardware, a higher level language can be used.EmbArBB is a Haskell embedding or the Intel ArBB system. EmbArBB relies on the ArBB system to generate code (via a Just-In-Time compiler) to a range of hardware. EmbArBB embeds a preexisting library for data-parallelism into Haskell and we obtain very good performance at little implementation effort. This performance comes from the expertise and effort put into the ArBB system and that we get for free. Embedding ArBB is a way to provide these benefits to the Haskell programmer and a way to increase usefulnessof an existing system by opening it up to a wider audience. Obsidian is very different; it is not based on a set of high-level parallel primitives. The Obsidian programmer can implement these primitives in different ways and then select the best one. We have obtained very good performance in case studies involving reductions. Obsidian programs are also more terse and composable, compared to CUDA.

Cited by 2

Optimization of Data Remapping in Data-Parallel Languages

Eduard Mehofer · 1998

The user-controlled mapping of data across the local memories of processing nodes is one of the central features of data-parallel languages like High Performance Fortran (HPF). Since many scientific applications typically consist of different computational phases owning each a best data mapping, dynamic remappings have proven useful in maintaining good data locality and workload balance. HPF supports remappings by procedure calls and by executing redistribute/realigndirectives. But remappings can be quite expensive as communication is required to migrate the array elements to their new owning processors and can significantly degrade a program's performance. Hence, elimination of unnecessary remappings is of key importance. It is essential because even well-written HPF programs may result in unnecessary remappings. In this thesis we optimize the overall time spent for dynamic data remappings in a program run by reducing the number of executed remappings. Elimination of redundant and d...

Cited by 0

Compilation Techniques for Embedded Data Parallel Languages

Catanzaro, Bryan Christopher · eScholarship (California Digital Library) · 2011

Contemporary parallel microprocessors exploit Chip Multiprocessing along with Single Instruction, Multiple Data parallelism to deliver high performance on applications that expose substantial fine-grained data parallelism. Although data parallelism is widely available in many computations, implementing data parallel algorithms in low-level efficiency languages such as C++ is often a difficult task, since the programmer is burdened with mapping data parallelism from an application onto the hardware structures designed to execute it. Languages specifically designed for data parallelism, such as NESL, aim to improve programmer productivity by allowing the programmer to express computation as a composition of data parallel primitives, such as map, reduce and scan. However, efficiently compiling nested data parallel computations to contemporary parallel microprocessors is challenging.Additionally, the rise of productivity languages, such as Ruby and Python, has facilitated the construction of domain-specific embedded languages. These embedded languages employ familiar syntactic constructs, which eases the task of learning a new programming environment, while also retaining the full capabilities of the host language. This work capitalizes on the productivity of domain-specific embedded languages as well as the nested data parallel abstraction to create a programming environment that is both productive and efficient on contemporary parallel microprocessors. We describe Copperhead, a high-level data parallel language embedded in Python. The Copperhead programmer writes parallel computations via composition of familiar data parallel primitives supporting both flat and nested data parallel computation on arrays of data. Copperhead programs are expressed in a subset of the widely used Python programming language and interoperate with standard Python modules, including libraries for numeric computation, data visualization, and analysis.Compiling data parallel computations requires analyses and transformations to schedule data parallel operations onto a target platform. We discuss the language, compiler, and runtime features that enable Copperhead to efficiently do so. We define the restricted subset of Python that Copperhead supports and introduce the program analysis techniques and transformations necessary for compiling Copperhead code into efficient low-level implementations. We demonstrate that indiscriminate use of the flattening or vectorization transform, common to data parallel compilers, is inefficient on contemporary microprocessors, and we advocate a more direct mapping of nested data parallel operations onto the natural parallelism hierarchy provided by today's parallel platforms. We show how this direct mapping allows a data parallel compiler to capitalize on hierarchical on-chip memory structures, as well as perform data parallel primitive fusion in order to gain efficiency. We outline the runtime support that allows Copperhead programs to efficiently interoperate with standard Python modules. We demonstrate the effectiveness of our techniques with several examples targeting the CUDA platform for parallel programming on graphics processors. Copperhead code is concise, on average requiring 3.6 times fewer lines of code than CUDA, and the compiler generates efficient low-level implementations, yielding 45-100% of the performance of hand-crafted, well optimized CUDA code. Copperhead provides an efficient and productive way to program parallel microprocessors.

Cited by 0Open access

A Formal Semantics of Data Parallel Languages

Eric Violard · 1998

The data parallel programming model appears as a good framework in which to develop software. Nevertheless, studies have still to be carried out about this model, especially in theoretical foundations. This paper is intended to show that these theories are met with by the theory PEI. As an illustration, we propose a language based on this theory and whose formal description can serve as sound semantics for data parallelism.

Cited by 0

Compiling Data-Parallel Languages for Distributed Memory Multi-Processors

Jesshope And, C R Jesshope, C. D. Sutton · 2007

This paper introduces a succinct intermediate representation for compiling high-level, data-parallel languages. It is shown how inferences applied to this representation can infer the necessary information to compile it into efficient code. Further inference procedures are being investigated in order to automatically distribute and align data objects on distributed memory multi-processors. The inferences shown in this paper are just those which infer the shape, type, rank and `sort' of data parallel operations. Shape inference and type inference create expressions (in the same representation) which evaluate to the type and shape at run-time. Thus the intermediate representation is polymorphic in terms of shape (the shape of data-parallel operations and variables) and type. Inference on an access sub-typing structure will eventually provide the mapping information. Compilers from Eval to F-code and from F-code to C exist and a new front-end compiler from FORTRAN 90 is being developed, a...

Cited by 0

Data Structure for the Parallel Execution of Functional Languages

Marino G, Succi G · Archivio istituzionale della ricerca (Alma Mater Studiorum Università di Bologna) · 1989

After a short review of some data structures proposed by traditional functional languages, some requirements that a data structuring primitives should meet for suitable implementation on parallel architectures are introduces; the drawbacks of the classic list data structure are evidenced and consequently two alternative structures are proposed; the first is based on unordered collection of objects (and hereafter called bag): its formal definition is given and the non-determinism of the related primitive operators are discussed; the second, limited functions, is a way for defining fuctions over finite and countable domains: its significant implication, mainly related with parallel architectures, are described. Examples of programs based on these concepts and integrated within the framework of an existing functional language are proposed and properties abot the primitives for manipulating unordered collections of objects are stated and proved in Appendix.

Cited by 0

CuNesl: Compiling Nested Data-Parallel Languages for SIMT Architectures

Yongpeng Zhang, Frank Mueller · 2012

Data-parallel languages feature fine-grained parallel primitives that can be supported by compilers targeting modern many-core architectures where data parallelism must be exploited to fully utilize the hardware. Previous research has focused on converting data-parallel languages for SIMD (single instruction multiple data) architectures. However, directly applying them to today's SIMT (single instruction multiple thread) architectures does not guarantee competitive performance. We propose cuNesl, a compiler framework to translate and optimize NESL into parallel CUDA programs for SIMT architectures. By converting recursive calls into while loops, we ensure that the hierarchical execution model in GPUs can be exploited on the "flattened" code. The performance gap between our auto-generated CUDA code and hand-crafted CUDA code thus narrows while programmability is greatly increased. Our compiler outperforms handwritten parallel code running on CPUs in terms of both execution time and programmability.

Cited by 15

Supporting data-level and processor-level parallelism in data-parallel programming languages

Philip J. Hatcher, Michael J. Quinn · 2002

The dataparallel C and C* languages do not allow the programmer to express both data-level and processor-level parallelism. Instead, the programmer must choose between them. Choosing data-level parallelism prevents the programmer from applying efficient sequential algorithms to data aggregates and causes unacceptable performance. Choosing processor-level parallelism forces the programmer to sequentialize fundamentally parallel data permutation or reduction operations through the use of 'for' loops. The authors give several prototypical examples that demonstrate how data-parallel algorithms can exhibit both data-level and processor-level parallelism. They suggest several ways that data-parallel programming languages or their compilers could be extended to support both kinds of parallelism, and discuss the advantages and disadvantages of each approach.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Cited by 2