here - Stefan-Marr.de

2. Context and Motivation
tasks with automatic and efficient load-balancing. When the execution model
provides only time shared execution, the overhead of fork/join is in most
implementations prohibitive [Kumar et al., 2012], especially when compared
to a sequential recursive implementation. Furthermore, the problem of loadbalancing
that is solved by work-stealing does not exist in the first place. To
conclude, parallel programming needs to solve problems that do not exist for
concurrent programs, and parallel programs require solutions that are not
necessarily applicable to concurrent programs.
Conversely, low-level atomic operations such as compare-and-swap have been
conceived in the context of few-core systems. One important use case was to
ensure that an operation is atomic with respect to interrupts on the same core.
One artifact of the design for time shared systems is that Intel’s compare-andswap
operation in the IA-32 instruction set (CMPXCHG) requires an additional
LOCK prefix to be atomic in multicore environments [Intel Corporation, 2012].
Similarly to the argumentation that parallel programming concepts do not
necessarily apply to time shared systems, the usefulness of low-level atomic
operations originating in concurrent systems is limited. Using them naively
restricts their scalability and their usefulness diminishes with rising degree of
parallelism [Shavit, 2011; Ungar, 2011]. They are designed to solve a particular
set of problems in concurrent programs but are not necessarily applicable to
the problems in parallel programs.
Concluding from these examples, it would be beneficial to treat concurrent
programming and parallel programming separately to properly reflect the characteristics
and applicability of the corresponding programming concepts.
2.3.2. Concurrent Programming and Parallel Programming
This section defines the notions of concurrent programming and parallel programming
to create two disjoint sets of programming concepts. Instead of focusing
on the execution model as earlier definitions do, the proposed definitions
concentrate on the aspect of programming, i. e., the process of formalizing
an algorithm using a number of programming concepts with a specific intent
and goal. The distinction between the execution model and the act of programming
is made explicitly to avoid confusion with the common usage of
the terms concurrency and parallelism.
One inherent assumption for these definitions is that they relate the notions
of concurrent and parallel programming with each other on a fixed level of
abstraction. Without assuming a fixed level of abstraction, it becomes easily
confusing because higher-level programming abstractions are typically built
20