Dataflow execution of sequential imperative programs on multicore architectures

Abstract

As multicore processors become the default, researchers are aggressively looking for program execution models that make it easier to use the available resources. Multithreaded programming models that rely on statically-parallel programs have gained prevalence. Most of the existing research is directed at adapting and enhancing such models, alleviating their drawbacks, and simplifying their usage. This paper takes a different approach and proposes a novel execution model to achieve parallel execution of statically-sequential programs. It dynamically parallelizes the execution of suitably-written sequential programs, in a dataflow fashion, on multiple processing cores. Significantly, the execution is race-free and determinate. Thus the model eases program development and yet exploits available parallelism. This paper describes the implementation of a software runtime library that implements the proposed execution model on existing commercial multicore machines. We present results from experiments running benchmark programs, using both the proposed technique as well as traditional parallel programming, on three different systems. We find that in addition to easing the development of the benchmarks, the approach is resource-efficient and achieves performance similar to the traditional approach, using stock compilers, operating systems and hardware, despite the overheads of an all-software implementation of the model.

Platform-independent analysis of function-level communication in workloads

“…The tasks themselves are self-contained and must execute completely before a dependent task can begin. The notion of a task is best represented by a function in a software implementation as functions are frequently re-used tasks [21]. However, functions are not self-contained as they make calls to other 198 functions before returning.…”

“…Gupta et. al [21] propose models to parallelize statically-sequential programs written in a suitable data flow fashion. However, their parallel executable functions are identified by programmers.…”

An Approach for Direct Dataflow Execution on Contemporary Multicore Systems

“…Subsequent works include tools for exploiting DDM on commodity multicores [19], [20], and the usage of DDM in HPC [4]. Targeting function level parallelism, Gupta and Sohi applied dataflow analysis to generate multithreaded code from imperative programs [8]. In contrast with the previous approaches, we start with a dataflow program and exploit different levels of parallelism including function calls, loop iteration and fused instructions.…”

MP-Tomasulo

“…In contrast, an adaptation of Instruction-Level Parallelism (ILP) scheduling algorithm to Task-Level Parallelism (TLP) provides a new insight to utilize the MPSoC platform effectively. Current cutting-edge studies such as Task Superscalar [Etsion et al 2010] and Gupta and Sohi [2011] explore new research directions into managing heterogeneous CMPs at a higher abstraction level. However, both approaches address the out-of-order task execution on a dedicated architecture without considerations for FPGA-based MPSoC platforms.…”