Executing functional programs on a virtual tree of processors

Burton, F. Warren; Sleep, M. R.

doi:10.1145/800223.806778

Cited by 144 publications

(58 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…First, to lower communication costs, we would like to steal large amounts of work, and in a tree-structured computation, shallow threads are likely to spawn more work than deep ones. This heuristic notion is the justification cited by earlier researchers [8,15,21,35,43] who proposed stealing work that is shallow in the spawn tree. We cannot, however, prove that shallow threads are more likely to spawn work than deep ones.…”

Section: The Cilk Work-stealing Schedulermentioning

confidence: 94%

“…Cilk' s scheduler uses the technique of work stealing [4,8,14,15,16,21,29,30,31,37,43] in which a processor (the thief) who runs out of work selects another processor (the victim) from whom to steal work, and then steals the shallowest ready thread in the victim's spawn tree. Cilk' s strategy is for thieves to choose victims at random [4,29,40].…”

Section: The Cilk Work-stealing Schedulermentioning

confidence: 99%

“…With P processors, the execution time cannot be less than T 1 =P or less than T 1 . The Cilk scheduler uses "work stealing" [4,8,14,15,16,21,29,30,31,37,43] to achieve execution time very near to the sum of these two measures. Off-line techniques for computing such efficient schedules have been known for a long time [6,18,19], but this efficiency has been difficult to achieve on-line in a distributed environment while simultaneously using small amounts of space and communication.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Cilk: An Efficient Multithreaded Runtime System

Blumofe¹,

Joerg²,

Kuszmaul³

et al. 1996

Journal of Parallel and Distributed Computing

939

924

View full text Add to dashboard Cite

Cilk (pronounced "silk") is a C-based runtime system for multithreaded parallel programming. In this paper, we document the efficiency of the Cilk work-stealing scheduler, both empirically and analytically. We show that on real and synthetic applications, the "work" and "critical-path length" of a Cilk computation can be used to model performance accurately. Consequently, a Cilk programmer can focus on reducing the computation' s work and critical-path length, insulated from load balancing and other runtime scheduling issues. We also prove that for the class of "fully strict" (well-structured) programs, the Cilk scheduler achieves space, time, and communication bounds all within a constant factor of optimal.The Cilk runtime system currently runs on the Connection Machine CM5 MPP, the Intel Paragon MPP, the Sun Sparcstation SMP, and the Cilk-NOW network of workstations. Applications written in Cilk include protein folding, graphic rendering, backtrack search, and the ?Socrates chess program, which won second prize in the 1995 World Computer Chess Championship.

show abstract

Section: The Cilk Work-stealing Schedulermentioning

confidence: 94%

Section: The Cilk Work-stealing Schedulermentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Cilk: An Efficient Multithreaded Runtime System

Blumofe¹,

Joerg²,

Kuszmaul³

et al. 1996

Journal of Parallel and Distributed Computing

939

924

View full text Add to dashboard Cite

show abstract

“…Agents make new work available to other agents (and also to itself) through a goal list which is associated with every stack set and which can be consulted by all the agents. This is an instance of the general class of work-stealing scheduling algorithms, which date back at least to Burton and Sleep's [4] research on parallel execution of functional programs and Halstead's [12] implementation of Multilisp, and the original &-Prolog abstract machine [13,16], for logic programs.…”

Section: Sketch Of a Shared Memory Implementationmentioning

confidence: 99%

“…Some actual implementations have chosen to place them in different parts of the available data areas. 4 When the first WAM executes the parallel conjunction r(X, Y) & s(X, Z), it pushes a parcall frame onto its stack and a goal descriptor onto its goal stack for the goal s(X, Z) (i.e., a pointer to the WAM code that will construct this call in the argument registers and another pointer to the appropriate environment), and it immediately starts executing r(X, Y). A second WAM, which is looking for jobs, picks s(X, Z) up, pushes an input marker into its stack (which references the parcall frame, where data common to all the goals is stored, to be used in case of internal failure) and constructs and starts executing the goal.…”

Section: Introductionmentioning

confidence: 99%

Towards a High-Level Implementation of Execution Primitives for Unrestricted, Independent And-Parallelism

Casas

Carro

Hermenegildo

Practical Aspects of Declarative Languages

View full text Add to dashboard Cite

Abstract. Most efficient implementations of parallel logic programming rely on complex low-level machinery which is arguably difficult to implement and modify. We explore an alternative approach aimed at taming that complexity by raising core parts of the implementation to the source language level for the particular case of and-parallelism. We handle a significant portion of the parallel implementation at the Prolog level with the help of a comparatively small number of concurrency-related primitives which take care of lower-level tasks such as locking, thread management, stack set management, etc. The approach does not eliminate altogether modifications to the abstract machine, but it does greatly simplify them and it also facilitates experimenting with different alternatives. We show how this approach allows implementing both restricted and unrestricted (i.e., non fork-join) parallelism. Preliminary experiments show that the performance sacrificed is reasonable, although granularity control is required in some cases. Also, we observe that the availability of unrestricted parallelism contributes to better observed speedups.

show abstract

@PT: Unobtrusive parallel programming with Java annotations

Mehrabi

Giacaman

Sinnen

2018

Concurrency and Computation

View full text Add to dashboard Cite

Parallel computing techniques have been supported by programming languages in two major ways: either library-based APIs or extended language constructs. Library-based features are portable and offer fine-grained control on parallelization details. However, they rely on individual programmer skills; thus, they may lead to inconsistent implementations and considerable code restructurings. On the contrary, language constructs promote environments that largely conceal the details of parallel programming techniques. However, they normally reduce programmer control over the granularity of parallelization and impose additional development concepts and compilation requirements that may sacrifice ease of use and portability. Therefore, approaches that balance between programmer control on parallelization details, intuitiveness of concepts, and portability can gain priority over other paradigms. In this paper, we discuss @PT (Annotation Parallel Task), a parallel computing framework that proposes Java annotations, standard Java components, as its language constructs. @PT takes an object-oriented approach on efficient execution and management of asynchronous tasks, with a special focus on GUI-responsive applications.This paper presents the annotation-based programming interface of the framework and its fundamental parallelization concepts. Furthermore, it studies the usability and performance of @PT by comparisons with other Java parallelization approaches in a set of standard benchmarks. The observations suggest that @PT maintains a simple programming interface, whereas it performs efficiently in different parallel computing domains. INTRODUCTIONThe proliferation of multi-core systems has encouraged support for parallel computing in shared-memory systems. The support is often offered in the form of libraries (eg, TPL and PLINQ in C# 1 ) or language constructs (eg, OpenMP 2 ). The majority of library-based approaches provide APIs that cover a wide range of fine-grained functions that can be combined to form flexible and efficient implementations for different parallel computing domains. Assembling and combining these functions for building a working system remains the responsibility of individual programmers. Here, the quality of software design depends on the programming approaches that are practiced by individuals. Reliance on the technical abilities and coding styles of individuals leads to inconsistent implementation and performance standards, some of which can be inefficient and complex to modify.In order to overcome the risks mentioned above, approaches such as Microsoft, PPL, 3 Java Streams, 4 SKePU, 5 and FastFlow 6 offer library APIs that implement frequent parallel processing patterns. Examples of these patterns are: map, reduce, farm, pipeline, asynchronous tasks, and so on. 5The pre-built components of these APIs improve consistency and efficiency across different implementations. In addition, these patterns can be composed to form bigger parallel applications. However, one needs to know what pattern to choose f...

show abstract

Executing functional programs on a virtual tree of processors

Cited by 144 publications

References 13 publications

Cilk: An Efficient Multithreaded Runtime System

Cilk: An Efficient Multithreaded Runtime System

Towards a High-Level Implementation of Execution Primitives for Unrestricted, Independent And-Parallelism

@PT: Unobtrusive parallel programming with Java annotations

Contact Info

Product

Resources

About