here - Stefan-Marr.de

2. Context and Motivation
driven to data driven computation. However, control driven programming,
i. e., imperative programming remains important.
Fork/Join utilizes the inherent parallelism in data-oriented problems by using
recursion to divide the computation into steps that can be processed in
parallel. It thereby makes an abstraction of the concrete data dependencies by
using recursive problem decomposition and relying on explicit synchronization
points when the result of a subproblem is required. While it is itself a
control-driven approach, relying on control-flow-based primitives, it is typically
used for data-parallel problems. However, it leaves it to the programmer
to align the program with its data-dependencies.
Cilk [Blumofe et al., 1995] introduced fork/join as a novel combination of
the classic recursive divide-and-conquer style of programming with an efficient
scheduling technique for parallel execution. Nowadays, it is widely
known as fork/join and available, e. g., for Java [Lea, 2000] and C/C++ with
libraries such as Intel’s Threading Building Blocks 13 . Primitives of this parallel
programming model are the spawn, i. e., fork operation, which will
result in a possibly parallel executing sub-computation, and the sync, i. e.,
join-operation, which will block until the corresponding sub-computation is
finished. Fork/join is a model for parallel programming in shared memory
environments. It enables developers to apply divide-and-conquer in a parallel
setting, however, it does not provide mechanisms to handle for instance
concurrency on global variables. Such mechanisms have been proposed [Frigo
et al., 2009], but the original minimal model focuses on the aspect of parallel
execution.
With work-stealing, Cilk also pioneered an efficient scheduling technique
that makes parallel divide-and-conquer algorithms practical for situations in
which a static schedule leads to significant load imbalances and thus suboptimal
performance.
MapReduce Functional programming languages have introduced the notion
of mapping a function on a sequence of values to produce a result sequence,
which then can be reduced to some result value with another function.
Based on this simple notion, distributed processing of data has become
popular [Lämmel, 2008]. For companies like Google, Microsoft, or Yahoo, processing
of large amounts of data became a performance challenge that required
the use of large clusters and resilient programming models. The model
13 http://threadingbuildingblocks.org/
34