Abstract not found

. This paper presents a new dialect of Scheme aimed towards concurrency and distribution. It offers a few primitives, including first-class continuations, with very simple semantics. Numerous examples are given showing how to program the classical concurrent control operators such as future, pcall and either. The implementation is sketched and presented along the lines of a metacircular interpreter. This paper presents the idiom of Icsla 1 , a language belonging to the Lisp family and more precisely a descendant of Scheme. This dialect has been designed with respect to the following main objectives: -- It should have a very simple and understandable semantics, with few but powerful and unrestrictively combinable concepts; -- It should offer concurrency, distribution and some other modern features such as sophisticated control features while not sacrificing the variety of styles traditionally offered by Lisp. These goals are rather general and deserve further comment. Following Sche...

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xiii 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.1 Motivation: The Problems of Parallel Programming . . . . . . . . . . . . . . . . . . . . . 2 1.2 A First Solution: Functional Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.3 A Refined Solution: Speculative Evaluation. . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.4 A Final Solution: Effective Speculative Evaluation . . . . . . . . . . . . . . . . . . . . . 12 1.5 Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.6 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2. Supercombinator Graph Reduction . . . . . . . . . . . . . . . . . . . . . . . . . ...

Advances in parallel computation are of central importance to Artificial Intelligence due to the significant amount of time and space their programs require. Functional languages have been identified as providing a clear and concise way of programming parallel machines for artificial intelligence tasks. The problems of exporting, creating, and manipulating processes have been thoroughly studied in relation to the parallelization of functional languages, but none of the necessary support structures needed for the abstraction, like a distributed memory, have been properly designed. In order to design and implement parallel functional languages efficiently, we propose the development of an all-software based distributed virtual memory system designed specifically for the memory demands of a functional language. In this paper, we review the MT architecture and briefly survey the related literature that lead to its development. We then present empirical results obtained from observing the paging behavior of the MT stack. Our empirical results suggest that LRU is superior to FIFO as a page replacement policy for MT stack pages. We present a proof that LRU is an opti-

. We describe a parallel object-oriented dialect of Scheme called ts/scheme that provides a simple and expressive interface for building asynchronous parallel programs. The main component in ts/scheme's coordination framework is an abstraction that serves the role of a distributed data structure. Distributed data structures are an extension of conventional data structures insofar as many tasks may simultaneously access and update their contents according to a well-defined serialization protocol. The semantics of these structures also specifies that consumers which attempt to access an as-of-yet undefined element are to block until a producer provides a value. ts/scheme permits the construction of two basic kinds of distributed data structures, those accessed by content, and those accessed by name. These structures can be further specialized and composed to yield a number of other synchronization abstractions. Our intention is to provide an efficient medium for expressing concurrency a...

ion Lawrence A. Crowl Oregon State University and Thomas J. LeBlanc University of Rochester Parallel programming involves finding the potential parallelism in an application and mapping it to the architecture at hand. Since a typical application has more potential parallelism than any single architecture can exploit effectively, programmers usually limit their focus to the parallelism that the available control constructs express easily and that the given architecture exploits efficiently. This approach produces programs that exhibit much less parallelism than exists in the application, and whose performance depends critically on the underlying hardware and software. We argue for an alternative approach based on control abstraction. Control abstraction is the process by which programmers define new control constructs, specifying constraints on statement ordering separately from an implementation of that ordering. With control abstraction programmers can define and use a rich variety o...

This paper addresses the importance of locality when migrating tasks of a parallel program between processors for load balancing in a multiprocessor. Static and preprocessing task scheduling algorithms work well for certain applications, but irregular problems often require dynamic load balancing. Many heuristics have been developed for scheduling the proper number of iterations of a parallel loop on each processor. Other techniques dynamically balance load by relocating tasks from busy processors to idle ones. Most of these approaches, however, neglect the cost of migrating a task from the processor on which it was originally created or assigned. This paper proposes using data affinity to help determine which tasks should be migrated from a heavily loaded processor to an idle one. Affinity is a measure of cost of moving the task and can be generated by the programmer or compiler, or it can be computed at runtime. This paper is intended to fulfill the area examination requirement in the MIT Department of Electrical Engineering and Computer Science.

This research is an attempt to reason about the control of parallel computation in the world of applicative programming languages. Applicative languages, in which computation is performed through function application and in which functions are treated as first-class objects, have the benefits of elegance, expressiveness and having clean semantics. Parallel computation and real-world concurrent activities are much harder to reason about than the sequential counterparts. Many parallel applicative languages have thus hidden most control details with their declarative programming styles, but they are not expressive enough to characterize many real world concurrent activities that can be easily explained with concepts such as message passing, pipelining and so on. Ease of programming should not come at the expense of expressiveness. Therefore, we design a parallel applicative language Pscheme such that programmers can express explicitly the control of parallel computation while maintaining ...

Supervising Committee: Acknowledgments Many people deserve and have my thanks for the help and support they have offered along the way. Warren Hunt Jr. has my gratitude for supervising this work. Matt Kaufmann created an ACL2 compilation flag that makes mv and mv-let thread safe. Since then he has helped refine the parallelism extension design, implementation, and documentation. Gary Byers has provided Closure Common Lisp (CCL, formerly known as OpenMCL) threading primitives in support of this project and has continually stepped up to the CCL implementation challenges this work has