Lazy threads: implementing a fast parallel call

 

Journal of Parallel and Distributed Computing

Seth Copen Goldstein, Klaus Erik Schauser, and David E. Culler

37(1):5–20, Orlando, FL, USA

1996

Abstract


download pdf


@article{goldstein96-jpdc,
  author = {Goldstein, Seth Copen and Schauser, Klaus Erik and Culler,
     David E.},
  title = {Lazy threads: implementing a fast parallel call},
  journal = {Journal of Parallel and Distributed Computing},
  volume = {37},
  number = {1},
  year = {1996},
  pages = {5--20},
  publisher = {Academic Press, Inc.},
  address = {Orlando, FL, USA},
  keywords = {Lazy Threads, Parallel Computing},
  url = {http://www.cs.cmu.edu/~seth/papers/goldstein96-jpdc.pdf},
  abstract = {In this paper, we describe lazy threads, a new approach
     for implementing multithreaded execution models on conventional
     machines. We show how they can implement a parallel call at
     nearly the efficiency of a sequential call. The central idea is
     to specialize the representation of a parallel call so that it
     can execute as a parallel-ready sequential call. This allows
     excess parallelism to degrade into sequential calls with the
     attendant efficient stack management and direct transfer of
     control and data, yet a call that truly needs to execute in
     parallel, gets its own thread of control. The efficiency of lazy
     threads is achieved through a careful attention to storage
     management and a code generation strategy that allows us to
     represent potential parallel work with no overhead.}
}

Related Papers
Parallel Computing
Brain in a Bottle
Seth Copen Goldstein. In Wild and Crazy Ideas Session of ASPLOS, October, 2006.
The Lazy Multithreaded Implementation Design Space
Seth Copen Goldstein and David E. Culler. In The Yale Multithreaded Workshop, June, 1998.
Lazy Threads Compiler and Runtime Structures for Fine-Grained Parallel Programming
Seth Copen Goldstein. PhD Thesis, University of California--Berkeley, 1997.
Lazy threads: implementing a fast parallel call
Seth Copen Goldstein, Klaus Erik Schauser, and David E. Culler. Journal of Parallel and Distributed Computing, 37(1):5–20,1996.
Enabling Primitives for Compiling Parallel Languages
Seth Copen Goldstein, David E. Culler, and Klaus Erik Schauser. In Third Workshop on Languages, Compilers, and Run-Time Systems for Scalable Computers, May, 1995.
How Much Non-Strictness Do Lenient Programs Require?
Klaus Erik Schauser and Seth Copen Goldstein. In Conference on Functional Programming Languages and Computer Architecture, June, 1995.
Introduction to Split-C
David E. Culler, Andrea Dusseau, Seth Copen Goldstein, Arvind Krishnamurthy, Steven Lumetta, Thorsten von Eicken, and Katherine Yelick. University of California--Berkeley Technical Report, April, 1995.
NIFDY: A Low Overhead, High Throughput Network Interface
Timothy J Callahan and Seth Copen Goldstein. In Proceedings of the 22nd International Symposium on Computer Architecture, June, 1995.
Separation Constraint Partitioning --- A New Algorithm for Partitioning non-Strict Programs Into Sequential Threads
Klaus Erik Schauser, David E. Culler, and Seth Copen Goldstein. In Proceedings of the Principles of Programming Languages, January, 1995.
Lazy Threads, Stacklets, and Synchronizers: Enabling primitives for compiling parallel languages
Seth Copen Goldstein, David E. Culler, and Klaus Erik Schauser. University of California at Berkeley Technical Report, 1995.
Active Messages: A Communication Foundation for Parallel Programming Models
Seth Copen Goldstein. In CM-5 Users Group, February, 1994.
The Implementation of a Threaded Abstract Machine
Seth Copen Goldstein. Master's Thesis, University of California at Berkeley, May, 1994. Also appeared as UC-Berkeley Technical Report UCB/CSD-94-818.
Parallel Programming in Split-C
David E. Culler, Andrea Dusseau, Seth Copen Goldstein, Arvind Krishnamurthy, Steven Lumetta, Thorsten von Eicken, and Katherine Yelick. In Proceedings of the Supercomputing '93 Conference, pages 262–273, November, 1993.
Evaluation of Mechanisms for Fine-Grained Parallel Programs in the J-Machine and the CM-5
Ellen Spertus, Seth Copen Goldstein, Klaus Erik Schauser, Thorsten von Eicken, David E. Culler, and William J. Dally. In Proceedings of the 20th International Symposium on Computer Architecture (ISCA), May, 1993.
TAM --- a compiler controlled threaded abstract machine
David E. Culler, Seth Copen Goldstein, Klaus Erik Schauser, and Thorsten von Eicken. Journal of Parallel and Distributed Computing, volume 18, pages 347–370,July, 1993.
Studying Dynamic Program Behavior `In the Large'
Seth Copen Goldstein. In ID Workshop, November, 1992.
Supporting Implicitly Parallel Languages
Seth Copen Goldstein. In 14th Annual Industrial Liaison Program Conference, March, 1992.
Active Messages: A Mechanism for Integrated Communication and Computation
Thorsten von Eicken, David E. Culler, Seth Copen Goldstein, and Klaus Erik Schauser. In Proceedings of the 19th International Symposium on Computer Architecture (ISCA), pages 430–440, May, 1992.
Empirical Study of a Dataflow Language on the CM-5
David E. Culler, Seth Copen Goldstein, Klaus Erik Schauser, and Thorsten von Eicken. In Proc. of the Dataflow Workshop, 19th Int'l Symposium on Computer Architecture, pages 187–210, May, 1992.
Hardware-Assisted Replay of Multiprocessor Programs
David F. Bacon and Seth Copen Goldstein. In Proceedings of the ACM/ONR Workshop on Parallel and Distributed Debugging, May, 1991.
Lazy Threads
The Lazy Multithreaded Implementation Design Space
Seth Copen Goldstein and David E. Culler. In The Yale Multithreaded Workshop, June, 1998.
Lazy Threads Compiler and Runtime Structures for Fine-Grained Parallel Programming
Seth Copen Goldstein. PhD Thesis, University of California--Berkeley, 1997.
Lazy threads: implementing a fast parallel call
Seth Copen Goldstein, Klaus Erik Schauser, and David E. Culler. Journal of Parallel and Distributed Computing, 37(1):5–20,1996.
Enabling Primitives for Compiling Parallel Languages
Seth Copen Goldstein, David E. Culler, and Klaus Erik Schauser. In Third Workshop on Languages, Compilers, and Run-Time Systems for Scalable Computers, May, 1995.
Lazy Threads, Stacklets, and Synchronizers: Enabling primitives for compiling parallel languages
Seth Copen Goldstein, David E. Culler, and Klaus Erik Schauser. University of California at Berkeley Technical Report, 1995.


Back to publications list