Performance and productivity in the multi-core era: challenges in software engineering and formal methods

FastFlow is a programming framework specifically targeting multi- and many-cores architetcures. It is implemented as a stack of C++ template libraries built on top of lock-free (and memory fence free) synchronization mechanisms. Its philosophy is to combine programmability with performance. In particular, FastFlow promotes (lock-free) pattern-based programming by providing programmers with extendible high-level parallel constructs, which are implemented as parametric streaming networks. They are realized by decoupling synchronizations of parallel activities, which are implemented in a message-passing style, and data exchange, which can be realized in both message-passing and shared-memory style (by way of pointer passing). This makes it possible: 1) to implement the whole run-time support in a lock-free and memory fence-free fashion, which ensures the efficient orchestration of fine-grained parallel activities on cache-coherent architectures (down to ~10 ns core-to-core synchronization latency); and 2) to employ different programming models to enhance locality or fast data movement according to the patterns’ high-level semantics. FastFlow’s expressivity will be illustrated by way of existing applications, which span different areas and include extensions to the programming model itself. Throughout the talk, the technological and methodological advances we advocate will be discussed in the perspective of challenges in formal methods to support performance and productivity in programming models we believe will characterize the multi-core era. More information at http://di.unito.it/fastflow