Abstract not found

The increasing availability of commodity multicore processors is making parallel computing available to the masses. Traditional parallel languages are largely intended for large-scale scientific computing and tend not to be well-suited to programming the applications one typically finds on a desktop system. Thus we need new parallel-language designs that address a broader spectrum of applications. In this paper, we present Manticore, a language for building parallel applications on commodity multicore hardware including a diverse collection of parallel constructs for different granularities of work. We focus on the implicitly-threaded parallel constructs in our high-level functional language. We concentrate on those elements that distinguish our design from related ones, namely, a novel parallel binding form, a nondeterministic parallel case form, and exceptions in the presence of data parallelism. These features differentiate the present work from related work on functional data parallel language designs, which has focused largely on parallel problems with regular structure and the compiler transformations — most notably, flattening — that make such designs feasible. We describe our implementation strategies and present some detailed examples utilizing various mechanisms of our language.

We present a complete redesign of Evaluation Strategies, a key abstraction for specifying pure, deterministic parallelism in Haskell. Our new formulation preserves the compositionality and modularity benefits of the original, while providing significant new benefits. First, we introduce an evaluation-order monad to provide clearer, more generic, and more efficient specification of parallel evaluation. Secondly, the new formulation resolves a subtle space management issue with the original strategies, allowing parallelism (sparks) to be preserved while reclaiming heap associated with superfluous parallelism. Related to this, the new formulation provides far better support for speculative parallelism as the garbage collector now prunes unneeded speculation. Finally, the new formulation provides improved compositionality: we can directly express parallelism embedded within lazy data structures, producing more compositional strategies, and our basic strategies are parametric in the coordination combinator, facilitating a richer set of parallelism combinators. We give measurements over a range of benchmarks demonstrating that the runtime overheads of the new formulation relative to the original are low, and the new strategies even yield slightly better speedups on average than the original strategies.

As a means of transmitting not only data but also code encapsulated within functions, higher-order channels provide an advanced form of task parallelism in parallel computations. In the presence of mutable references, however, they pose a safety problem because references may be transmitted to remote threads where they are no longer valid. This paper presents an ML-like parallel language with typesafe higher-order channels. By type safety, we mean that no value written to a channel contains references, or equivalently, that no reference escapes via a channel from the thread where it is created. The type system uses a typing judgment that is capable of deciding whether the value to which a term evaluates contains references or not. The use of such a typing judgment also makes it easy to achieve another desirable feature of channels, channel locality, that associates every channel with a unique thread for serving all values addressed to it. Our type system permits mutable references in sequential computations and also ensures that mutable references never interfere with parallel computations. Thus it provides both flexibility in sequential programming and ease of implementing parallel computations.

We present a new programming model for deterministic parallel computation in a pure functional language. The model is monadic and has explicit granularity, but allows dynamic construction of dataflow networks that are scheduled at runtime, while remaining deterministic and pure. The implementation is based on monadic concurrency, which has until now only been used to simulate concurrency in functional languages, rather than to provide parallelism. We present the API with its semantics, and argue that parallel execution is deterministic. Furthermore, we present a complete workstealing scheduler implemented as a Haskell library, and we show that it performs at least as well as the existing parallel programming models in Haskell. 1.

Abstract- SequenceL is a concise, high-level language with a simple semantic that provides for the automatic derivation of many iterative and parallel control structures. The semantic repeatedly applies a “Normalize-Transpose ” operation to functions and operators until base cases are discovered, which include the grounding of variables and the application of built-in operators to operands of appropriate types. This paper introduces the language from an intuitive point of view, indicating the scalability of the normalize-transpose, the different forms of recursion supported by the language and its abstraction, and new shorthand methods for specifying additional iterative/recursive problem solutions.

Abstract. The implemented Clean-CORBA and Haskell-CORBA interfaces open a way for developing parallel and distributed applications on clusters consisting of components written in functional programming languages, like Clean and Haskell. We focus on a specific application of this tool in this paper. We design and implement an abstract communication layer based on CORBA server objects. Using this layer we can build up computations in form of distributed process-networks consisting of components written in several programming languages, some components written in functional style in Clean, while other components written in an object-oriented language like Java or C++. The speed-up of computations is investigated using a simple example. 1

Abstract. The presented Clean-CORBA interface opens the way for developing parallel and distributed applications consisting of components written in a functional programming language, Clean. The interface defines a language mapping from the IDL language used by CORBA to Clean. It contains an IDL-to-Clean compiler which generates the necessary stub and skeleton routines from the IDL files. The interface is a general tool for connecting functional Clean programs and programs written in any language using a CORBA interface via the network. We focus on a specific application of this tool in this paper, we build a software architecture for programming clusters using the functional communication layer based on CORBA server objects. Using this architecture we can build up applications consisting components written in several programming languages, some components written in pure functional style in Clean, while other components written in an objectoriented language like Java or C#. Based on this software architecture the field of skeletal programming is studied, which suits very well with the functional programming. A skeleton for pipeline computing is chosen as an example to present the main features of this approach. 1

SequenceL is a concise, high-level language with a simple semantic that provides for the automatic derivation of many iterative and parallel control structures. The semantic repeatedly applies a “Normalize-Transpose-Distribute ” operation to functions and operators until base cases are discovered. Base cases include the grounding of variables and the application of built-in operators to operands of appropriate types. This paper introduces the results of a 24-month effort to reduce the language to a very small set of primitives. Included are comparisons with other languages, the formal syntax and semantics, and the traces of several example problems run with a prototype interpreter developed in 2006.

First of all, I would like to thank Prof. Dr. Claudia Leopold for giving me the opportunity to work in her group of “Programming Languages and Parallel Programming ” at University of Kassel and Prof. Dr. Emre Harmancı who accepted to be my supervisor. Prof. Leopold never let me alone even in the rest of my work in Turkey. Working at University of Kassel was a great experience for me. I feel fortunate to have helpful friends, Björn Knafla and Michael Süss who made my first time in Germany enjoyable. Thanks to Christiane Becker and Raffaele Biscosi for being so nice to me. I am grateful to Dr. Turgay Altılar who encouraged me for the presentations and helped me a lot. Special thanks to my parents who always supported me. December 2004 Ay¸se Beliz S¸enyüz iv TABLE OF CONTENTS ABBREVIATIONS viii