source: doc/proposals/concurrency/text/intro.tex @ 5c4f2c2

Last change on this file since 5c4f2c2 was 5c4f2c2, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

Updated thesis with most of Gregor's comments

  • Property mode set to 100644
File size: 2.5 KB
1% ======================================================================
3% ======================================================================
4This thesis provides a minimal concurrency \acrshort{api} that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of concurrency. Indeed, for highly productive concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. The high-level approach and its minimal \acrshort{api} are tested in a dialect of C, called \CFA. Furthermore, the proposed \acrshort{api} doubles as an early definition of the \CFA language and library. This thesis also comes with an implementation of the concurrency library for \CFA as well as all the required language features added to the source-to-source translator.
6There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmer. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.
8In the context of this thesis, a thread is a fondamental unit of execution which runs a sequence of code, generally on a program stack. Having multiple concurrent threads gives rise to concurrency and generally requires some kind of locking mechnism to ensure proper execution. Correspondingly, concurrency is defined as the concepts and challenges which occur when multiple independant (sharing memory, timing dependencies, etc.) concurrent threads are introduced. Accordingly, locking (and by extension locks) are defined as a mechanism which prevents the progress of certain threads in order to avoid problems due to concurrency. Finally, in this thesis parallelism is distinct from concurrency and is defined as running multiple threads simultaneously. More precisely, parallelism implies \emph{actual} simulataneous execution as oposed to concurrency which only requires \emph{apparent} simultaneous execution. As such, parallelism is only observable in the differences in performance or, more generally, differences in timing.
Note: See TracBrowser for help on using the repository browser.