John Reppy's Publications

Concurrency, Distributed Systems, and Parallelism


Compiling with continuations and LLVM.
Kavon Farvardin and John Reppy. In Proceedings of the 2016 ACM SIGPLAN Workshop on ML, September 2016.
bib | .pdf ]

This paper describes a new LLVM-based backend for the Parallel ML compiler (part of the Manticore system). This backend is novel in that it supports heap-allocated first-class continuations (a first for LLVM), which, in turn enables language features, such as callcc, lightweight concurrency mechanisms, and PML's parallelism features.

λcu --- An Intermediate Representation for Compiling Nested Data Parallelism, John Reppy and Joe Wingerter. Presented at the Compilers for Parallel Computing Workshop (CPC '16), July 2016. Valladolid, Spain.
bib | .pdf ]

Modern GPUs provide supercomputer-level performance at commodity prices, but they are notoriously hard to program. GPUs enable a vast degree of parallelism, but only a small set of control-flow and data access patterns are efficient to run on GPU architectures. In order to provide programmers with a familiar, high-level programming paradigm that nonetheless maps efficiently to GPU hardware, we have been exploring the use of Nested Data Parallelism (NDP), specifically the first-order functional language NESL.

NESL, originally designed for SIMD architectures, is a functional language with an apply-to-each construct and other parallel primitives that enables the expression of irregular parallel algorithms; Blelloch and others developed a global flattening transformation that maps irregular NDP code into regular flat data parallel (FDP) code suitable for SIMD execution. Our prior work on the Nessie compiler targetted SIMT GPUs via CUDA, establishing the feasibility of such a translation, but with poor performance compared to tuned CUDA implementations by human experts, primarily due to allocation of and memory traffic to temporary arrays.

In this work, we focus on a compiler IR, called λcu that we have designed to support effective optimization of the FDP code produced by the flattening transformation. λcu is a three-level language consisting of a top-level representation for the CPU-level control flow, a mid-level language for representing the iteration structure of GPU kernels, and a low-level language for representing the computations performed on the GPU.

λcu facilitates fusion of parallel operations by expressing iteration structures with a language of combinators, which obey a set of fusion rules described in this paper. Some fusion optimizations are mutually exclusive, so following Robinson et al. we use an ILP solver to determine the optimal fusion of kernels and then perform the recommended fusions. Final generation of CUDA code is performed on each fused group of combinators, linking CUDA kernels using a backbone of generated C++ which directs program progress on the CPU.

Diderot: a Domain-Specific Language for Portable Parallel Scientific Visualization and Image Analysis.
Gordon Kindlmann, Charisee Chiw, Lamont Samuels, Nick Seltzer, and John Reppy. IEEE Transactions on Visualization and Computer Graphics, pages 867--876, October 2015.
bib | .pdf ]

Many algorithms for scientific visualization and image analysis are rooted in the world of continuous scalar, vector, and tensor fields, but are programmed in low-level languages and libraries that obscure their mathematical foundations. Diderot is a parallel domain-specific language that is designed to bridge this semantic gap by providing the programmer with a high-level, mathematical programming notation that allows direct expression of mathematical concepts in code. Furthermore, Diderot provides parallel performance that takes advantage of modern multicore processors and GPUs. The high-level notation allows a concise and natural expression of the algorithms and the parallelism allows efficient execution on real-world datasets.

Nessie: A NESL to CUDA Compiler, John Reppy and Nora Sandler. Presented at the Compilers for Parallel Computing Workshop (CPC '15), January 2015. Imperial College, London, UK.
bib | .pdf ]

Modern GPUs provide supercomputer-level performance at commodity prices, but they are notoriously hard to program. To address this problem, we have been exploring the use of Nested Data Parallelism (NDP), and specifically the first-order functional language Nesl, as a way to raise the level of abstraction for programming GPUs. This paper describes a new compiler for Nesl language that generated CUDA code. Specifically we describe three aspects of the compiler that address some of the challenges of generating efficient NDP code for GPUS.

Bulk-Synchronous Communication Mechanisms in Diderot, John Reppy and Lamont Samuels. Presented at the Compilers for Parallel Computing Workshop (CPC '15), January 2015. Imperial College, London, UK.
bib | .pdf ]

Diderot is a parallel domain-specific language designed to provide biomedical researchers with a high-level mathematical programming model where they can use familiar tensor calculus notations directly in code without dealing with underlying low-level implementation details. These operations are executed as parallel independent computations. We use a bulk synchronous parallel model (BSP) to execute these independent computations as autonomous lightweight threads called strands. The current BSP model of Diderot limits strand creation to initialization time and does not provide any mechanisms for communicating between strands. For algorithms, such as particle systems, where strands are used to explore the image space, it is useful to be able to create new strands dynamically and share data between strands.

In this paper, we present an updated BSP model with three new features: a spatial mechanism that retrieves nearby strands based on their geometric position in space, a global mechanism for global computations (i.e., parallel reductions) over sets of strands and a mechanism for dynamically allocating new strands. We also illustrate through examples how to express these features in the Diderot language. More, generally, by providing a communication system with these new mechanisms, we can effectively increase the class of applications that Diderot can support.

Data-Only Flattening for Nested Data Parallelism.
Lars Bergstrom, Matthew Fluet, Mike Rainey, John Reppy, Stephen Rosen, and Adam Shaw. In Proceedings of the 2013 ACM SIGPLAN Symposium on Principles & Practice of Parallel Programming (PPoPP 2013), pages 81--92, New York, NY, February 2013. ACM.
bib | .pdf ]

Data parallelism has proven to be an effective technique for high-level programming of a certain class of parallel applications, but it is not well suited to irregular parallel computations. Blelloch and others proposed nested data parallelism (NDP) as a language mechanism for programming irregular parallel applications in a declarative data-parallel style. The key to this approach is a compiler transformation that flattens the NDP computation and data structures into a form that can be executed efficiently on a wide-vector SIMD architecture. Unfortunately, this technique is ill suited to execution on today's multicore machines. We present a new technique, called data-only flattening, for the compilation of NDP, which is suitable for multicore architectures. Data-only flattening transforms nested data structures in order to expose programs to various optimizations while leaving control structures intact. We present a formal semantics of data-only flattening in a core language with a rewriting system. We demonstrate the effectiveness of this technique in the Parallel ML implementation and we report encouraging experimental results across various benchmark applications.

Lazy Tree Splitting.
Lars Bergstrom, Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Journal of Functional Programming, 22(4-5):382--438, September 2012.
bib ]

Nested data-parallelism (NDP) is a language mechanism that supports programming irregular parallel applications in a declarative style. In this paper, we describe the implementation of NDP in Parallel ML (PML), which is part of the Manticore system. One of the main challenges of implementing NDP is managing the parallel decomposition of work. If we have too many small chunks of work, the overhead will be too high, but if we do not have enough chunks of work, processors will be idle. Recently the technique of Lazy Binary Splitting was proposed to address this problem for nested parallel loops over flat arrays. We have adapted this technique to our implementation of NDP, which uses binary trees to represent parallel arrays. This new technique, which we call Lazy Tree Splitting (LTS), has the key advantage of performance robustness; i.e., that it does not require tuning to get the best performance for each program. We describe the implementation of the standard NDP operations using LTS and we present experimental data that demonstrates the scalability of LTS across a range of benchmarks.

Nested Data-Parallelism on the GPU.
Lars Bergstrom and John Reppy. In Proceedings of the 17th ACM SIGPLAN International Conference on Functional Programming (ICFP 2012), pages 247--258, New York, NY, September 2012. ACM.
bib | .pdf ]

Graphics processing units (GPUs) provide both memory bandwidth and arithmetic performance far greater than that available on CPUs but, because of their Single-Instruction-Multiple-Data (SIMD) architecture, they are hard to program. Most of the programs ported to GPUs thus far use traditional data-level parallelism, performing only operations that operate uniformly over vectors.

NESL is a first-order functional language that was designed to allow programmers to write irregular-parallel programs --- such as parallel divide-and-conquer algorithms --- for wide-vector parallel computers. This paper presents our port of the NESL implementation to work on GPUs and provides empirical evidence that nested data-parallelism (NDP) on GPUs significantly outperforms CPU-based implementations and matches or beats newer GPU languages that support only flat parallelism. While our performance does not match that of hand-tuned CUDA programs, we argue that the notational conciseness of NESL is worth the loss in performance. This work provides the first language implementation that directly supports NDP on a GPU.

Diderot: A Parallel DSL for Image Analysis and Visualization.
Charisee Chiw, Gordon Kindlmann, John Reppy, Lamont Samuels, and Nick Seltzer. In Proceedings of the SIGPLAN 2012 Conference on Programming Language Design and Implementation, pages 111--120, New York, NY, June 2012. ACM.
bib | .pdf ]

Research scientists and medical professionals use imaging technology, such as computed tomography (CT) and magnetic resonance imaging (MRI) to measure a wide variety of biological and physical objects. The increasing sophistication of imaging technology creates demand for equally sophisticated computational techniques to analyze and visualize the image data. Analysis and visualization codes are often crafted for a specific experiment or set of images, thus imaging scientists need support for quickly developing codes that are reliable, robust, and efficient.

In this paper, we present the design and implementation of Diderot, which is a parallel domain-specific language for biomedical image analysis and visualization. Diderot supports a high-level model of computation that is based on continuous tensor fields. These tensor fields are reconstructed from discrete image data using separable convolution kernels, but may also be defined by applying higher-order operations, such as differentiation. Early experiments demonstrate that Diderot provides both a high-level concise notation for image analysis and visualization algorithms, as well as high sequential and parallel performance.

Implicitly threaded parallelism in Manticore.
Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Journal of Functional Programming, 20(5-6):537--576, 2011.
bib ]

The increasing availability of commodity multicore processors is making parallel computing ever more widespread. In order to exploit its potential, programmers need languages that make the benefits of parallelism accessible and understandable. Previous parallel languages have traditionally been intended for large-scale scientific computing, and they 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. The Manticore project is our effort to address this need. At its core is Parallel ML, a high-level functional language for programming parallel applications on commodity multicore hardware. Parallel ML provides a diverse collection of parallel constructs for different granularities of work. In this paper, we focus on the implicitly threaded parallel constructs of the language, which support fine-grained parallelism. We concentrate on those elements that distinguish our design from related ones, namely, a novel parallel binding form, a nondeterministic parallel case form, and the treatment of exceptions in the presence of data parallelism. These features differentiate the present work from related work on functional data-parallel language designs, which have focused largely on parallel problems with regular structure and the compiler transformations --- most notably, flattening --- that make such designs feasible. We present detailed examples utilizing various mechanisms of the language and give a formal description of our implementation.

Lazy Tree Splitting.
Lars Bergstrom, Mike Rainey, John Reppy, Adam Shaw, and Matthew Fluet. In Proceedings of the 15th ACM SIGPLAN International Conference on Functional Programming (ICFP 2010), pages 93--104, New York, NY, September 2010. ACM.
bib | .pdf ]

Nested data-parallelism (NDP) is a declarative style for programming irregular parallel applications. NDP languages provide language features favoring the NDP style, efficient compilation of NDP programs, and various common NDP operations like parallel maps, filters, and sum-like reductions. In this paper, we describe the implementation of NDP in Parallel ML (PML), part of the Manticore project. Managing the parallel decomposition of work is one of the main challenges of implementing NDP. If the decomposition creates too many small chunks of work, performance will be eroded by too much parallel overhead. If, on the other hand, there are too few large chunks of work, there will be too much sequential processing and processors will sit idle.

Recently the technique of Lazy Binary Splitting was proposed for dynamic parallel decomposition of work on flat arrays, with promising results. We adapt Lazy Binary Splitting to parallel processing of binary trees, which we use to represent parallel arrays in PML. We call our technique Lazy Tree Splitting (LTS). One of its main advantages is its performance robustness: per-program tuning is not required to achieve good performance across varying platforms. We describe LTS-based implementations of standard NDP operations, and we present experimental data demonstrating the scalability of LTS across a range of benchmarks.

Programming in Manticore, a Heterogeneous Parallel Functional Language.
Matthew Fluet, Lars Bergstrom, Nic Ford, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. In Zoltan Horváth, editor, Central European Functional Programming School, Volume 6299 of Lecture Notes in Computer Science, pages 94--145, New York, NY, 2010. Springer-Verlag.
bib ]

Parallel Concurrent ML.
John Reppy, Claudio Russo, and Yingqi Xiao. In Proceedings of the 14th ACM SIGPLAN International Conference on Functional Programming (ICFP 2009), pages 257--268, New York, NY, September 2009. ACM.
bib | .pdf ]

Concurrent ML (CML) is a high-level message-passing language that supports the construction of first-class synchronous abstractions called events. This mechanism has proven quite effective over the years and has been incorporated in a number of other languages. While CML provides a concurrent programming model, its implementation has always been limited to uniprocessors. This limitation is exploited in the implementation of the synchronization protocol that underlies the event mechanism, but with the advent of cheap parallel processing on the desktop (and laptop), it is time for Parallel CML.

Parallel implementations of CML-like primitives for Java and Haskell exist, but build on high-level synchronization constructs that are unlikely to perform well. This paper presents a novel, parallel implementation of CML that exploits a purpose-built optimistic concurrency protocol designed for both correctness and performance on shared-memory multiprocessors. This work extends and completes an earlier protocol that supported just a strict subset of CML with synchronization on input, but not output events. Our main contributions are a model-checked reference implementation of the protocol and two concrete implementations. This paper focuses on Manticore's functional, continuation-based implementation but briefly discusses an independent, thread-based implementation written in C# and running on Microsoft's stock, parallel runtime. Although very different in detail, both derive from the same design. Experimental evaluation of the Manticore implementation reveals good performance, despite the extra overhead of multiprocessor synchronization.

Implicitly-threaded parallelism in Manticore.
Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. In Proceedings of the 13th ACM SIGPLAN International Conference on Functional Programming (ICFP 2008), pages 119--130, September 2008.
bib | .pdf ]

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.

A scheduling framework for general-purpose parallel languages.
Matthew Fluet, Mike Rainey, and John Reppy. In Proceedings of the 13th ACM SIGPLAN International Conference on Functional Programming (ICFP 2008), pages 241--252, September 2008.
bib | .pdf ]

The trend in microprocessor design toward multicore and manycore processors means that future performance gains in software will largely come from harnessing parallelism. To realize such gains, we need languages and implementations that can enable parallelism at many different levels. For example, an application might use both explicit threads to implement course-grain parallelism for independent tasks and implicit threads for fine-grain data-parallel computation over a large array. An important aspect of this requirement is supporting a wide range of different scheduling mechanisms for parallel computation.

In this paper, we describe the scheduling framework that we have designed and implemented for Manticore, a strict parallel functional language. We take a micro-kernel approach in our design: the compiler and runtime support a small collection of scheduling primitives upon which complex scheduling policies can be implemented. This framework is extremely flexible and can support a wide range of different scheduling policies. It also supports the nesting of schedulers, which is key to both supporting multiple scheduling policies in the same application and to hierarchies of speculative parallel computations.

In addition to describing our framework, we also illustrate its expressiveness with several popular scheduling techniques. We present a (mostly) modular approach to extending our schedulers to support cancellation. This mechanism is essential for implementing eager and speculative parallelism. We finally evaluate our framework with a series of benchmarks and an analysis.

Toward a parallel implementation of Concurrent ML.
John Reppy and Yingqi Xiao. In Proceedings of the Workshop on Declarative Aspects of Multicore Programming (DAMP 2008), January 2008.
bib | .pdf ]

Concurrent ML (CML) is a high-level message-passing language that supports the construction of first-class synchronous abstractions called events. This mechanism has proven quite effective over the years and has been incorporated in a number of other languages. While CML provides a concurrent programming model, its implementation has always been limited to uniprocessors. This limitation is exploited in the implementation of the synchronization protocol that underlies the event mechanism, but with the advent of cheap parallel processing on the desktop (and laptop), it is time for Parallel CML.

We are pursuing such an implementation as part of the Manticore project. In this paper, we describe a parallel implementation of Asymmetric CML (ACML), which is a subset of CML that does not support output guards. We describe an optimistic concurrency protocol for implementing CML synchronization. This protocol has been implemented as part of the Manticore system.

Status Report: The Manticore Project.
Matthew Fluet, Nic Ford, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. In Proceedings of the 2007 ACM SIGPLAN Workshop on ML, pages 15--24, October 2007.
bib | .pdf ]

The Manticore project is an effort to design and implement a new functional language for parallel programming. Unlike many earlier parallel languages, Manticore is a heterogeneous language that supports parallelism at multiple levels. Specifically, we combine CML-style explicit concurrency with fine-grain, implicitly threaded, parallel constructs. We have been working on an implementation of Manticore for the past six months; this paper gives an overview of our design and a report on the status of the implementation effort.

Specialization of CML message-passing primitives.
John Reppy and Yingqi Xiao. In Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL 2007), pages 315--326, January 2007.
bib | .pdf ]

Concurrent ML (CML) is a statically-typed higher-order concurrent language that is embedded in Standard ML. Its most notable feature is its support for first-class synchronous operations. This mechanism allows programmers to encapsulate complicated communication and synchronization protocols as first-class abstractions, which encourages a modular style of programming where the underlying channels used to communicate with a given thread are hidden behind data and type abstraction.

While CML has been in active use for well over a decade, little attention has been paid to optimizing CML programs. In this paper, we present a new program analysis for statically-typed higher-order concurrent languages that enables the compile-time specialization of communication operations. This specialization is particularly important in a multiprocessor or multicore setting, where the synchronization overhead for general-purpose operations are high. Preliminary results from a prototype that we have built demonstrate that specialized channel operations are much faster than the general-purpose operations.

Our analysis technique is modular (i.e., it analyzes and optimizes a single unit of abstraction at a time), which plays to the modular style of many CML programs. The analysis consists of three steps: the first is a type-sensitive control-flow analysis that uses the program's type-abstractions to compute more precise results. The second is the construction of an extended control-flow graph using the results of the CFA. The last step is an iterative analysis over the graph that approximates the usage patterns of known channels. Our analysis is designed to detect special patterns of use, such as one-shot channels, fan-in channels, and fan-out channels. We have proven the safety of our analysis and state those results.

Manticore: A heterogeneous parallel language.
Matthew Fluet, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. In Proceedings of the Workshop on Declarative Aspects of Multicore Programming (DAMP 2007), pages 37--44, January 2007.
bib | .pdf ]

The Manticore project is an effort to design and implement a new functional language for parallel programming. Unlike many earlier parallel languages, Manticore is a heterogeneous language that supports parallelism at multiple levels. Specifically, we combine CML-style explicit concurrency with NESL/Nepal-style data-parallelism. In this paper, we describe and motivate the design of the Manticore language. We also describe a flexible runtime model that supports multiple scheduling disciplines (e.g., for both fine-grain and course-grain parallelism) in a uniform framework. Work on a prototype implementation is ongoing and we give a status report.

Compiler support for lightweight concurrency.
Kathleen Fisher and John Reppy. Technical memorandum, Bell Labs, March 2002.
bib | .pdf ]

Asynchronous exceptions in Haskell.
Simon Marlow, Simon Peyton Jones, Andrew Moran, and John Reppy. In Proceedings of the SIGPLAN 2001 Conference on Programming Language Design and Implementation, June 2001.
bib ]

Protium: An infrastructure for partitioned applications.
Cliff Young, Lakshman Y.N., Tom Szymanski, John Reppy, David Presotto, Rob Pike, Girija Narlikar, Sape Mullender, and Eric Grosse. In Proceedings of the Eighth Workshop on Hot Operating Systems (HotOS-VIII), January 2001.
bib | .pdf ]

Concurrent Programming in ML.
John H. Reppy. Cambridge University Press, Cambridge, England, 1999.
bib ]

The Essence of Concurrent ML.
Prakash Panangaden and John Reppy. In Flemming Nielson, editor, ML with Concurrency, Chapter 1. Springer-Verlag, 1997.
bib ]

Supporting SPMD Execution for Dynamic Data Structures.
Martin Carlisle, Laurie J. Hendren, Anne Rogers, and John Reppy. ACM Transactions on Programming Languages and Systems, 17(2):233--263, March 1995.
bib ]

Early experiences with Olden.
Martin Carlisle, Anne Rogers, John Reppy, and Laurie Hendren. In 6th International Workshop on Languages and Compilers for Parallel Computing, number 768 in Lecture Notes in Computer Science, August 1993.
bib ]

A Multi-threaded Higher-order User Interface Toolkit.
Emden R. Gansner and John H. Reppy. In User Interface Software, Bass and Dewan (Eds.), Volume 1 of Software Trends, pages 61--80. John Wiley & Sons, 1993.
bib ]

Concurrent ML: Design, application and semantics.
John H. Reppy. In Peter Lauer, editor, Functional Programming, Concurrency, Simulation and Automated Reasoning, number 693 in Lecture Notes in Computer Science. Springer-Verlag, New York, NY, 1993.
bib ]

Supporting SPMD Execution for Dynamic Data Structures.
Anne Rogers, John Reppy, and Laurie Hendren. In 5th International Workshop on Languages and Compilers for Parallel Computing, number 757 in Lecture Notes in Computer Science, August 1992.
bib ]

Higher-order Concurrency.
John H. Reppy. PhD thesis, Cornell University, 1992. Available as Computer Science Technical Report 92-1285.
bib ]

A Foundation for User Interface Construction.
Emden R. Gansner and John H. Reppy. In Brad Myers, editor, Languages for Developing User Interfaces, Chapter 14. Jones and Bartlett, 1992.
bib ]

CML: A higher-order concurrent language.
John H. Reppy. In Proceedings of the SIGPLAN 1991 Conference on Programming Language Design and Implementation, pages 293--305, New York, NY, June 1991. ACM.
bib ]

eXene.
Emden R. Gansner and John H. Reppy. In Third International Workshop on ML, September 1991.
bib ]

Asynchronous signals in Standard ML.
John H. Reppy. Technical Report TR 90-1144, Department of Computer Science, Cornell University, Ithaca, NY, August 1990.
bib ]

Synchronous Operations as First-class Values.
John H. Reppy. In Proceedings of the SIGPLAN 1988 Conference on Programming Language Design and Implementation, June 1988.
bib ]

Concurrent Garbage Collection on Stock Hardware.
Steven C. North and John H. Reppy. In Third International Conference on Functional Programming Languages and Computer Architecture, Volume 274 of Lecture Notes in Computer Science, pages 113--133, New York, NY, September 1987. Springer-Verlag.
bib ]


This file was generated by bibtex2html 1.98.


Last updated on August 31, 2018
Comments to John Reppy.