Inference and Declaration of Independence in Task-Parallel Programs

Zakkak, Foivos S.; Chasapis, Dimitrios; Pratikakis, Polyvios; Bilas, Angelos; Nikolopoulos, Dimitrios S.

doi:10.1007/978-3-642-45293-2_1

Cited by 4 publications

(7 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In past work [6], we defined the semantics of the programming model and formally proved that its parallel execution on non-coherent systems is always deterministic and equivalent to a serial execution. We use a source-to-source compiler [10] to translate pragma-annotated C code to plain C code with calls to the Myrmics API, which is described in section V (Fig. 4).…”

Section: Background: Programming Modelmentioning

confidence: 99%

Myrmics: Scalable, Dependency-aware Task Scheduling on Heterogeneous Manycores

Lyberis¹,

Pratikakis²,

Mavroidis³

et al. 2016

Preprint

Self Cite

View full text Add to dashboard Cite

Task-based programming models have become very popular, as they offer an attractive solution to parallelize serial application code with task and data annotations. They usually depend on a runtime system that schedules the tasks to multiple cores in parallel while resolving any data hazards. However, existing runtime system implementations are not ready to scale well on emerging manycore processors, as they often rely on centralized structures and/or locks on shared structures in a cache-coherent memory. We propose design choices, policies and mechanisms to enhance runtime system scalability for single-chip processors with hundreds of cores. Based on these concepts, we create and evaluate Myrmics, a runtime system for a dependencyaware, task-based programming model on a heterogeneous hardware prototype platform that emulates a single-chip processor of 8 latency-optimized and 512 throughput-optimized CPUs. We find that Myrmics scales successfully to hundreds of cores. Compared to MPI versions of the same benchmarks with handtuned message passing, Myrmics achieves similar scalability with a 10-30% performance overhead, but with less programming effort. We analyze the scalability of the runtime system in detail and identify the key factors that contribute to it.

show abstract

Section: Background: Programming Modelmentioning

confidence: 99%

Myrmics: Scalable, Dependency-aware Task Scheduling on Heterogeneous Manycores

Lyberis¹,

Pratikakis²,

Mavroidis³

et al. 2016

Preprint

Self Cite

View full text Add to dashboard Cite

show abstract

“…The programming model is implemented by a source-tosource compiler, based on the SCOOP [23] infrastructure. It recognizes the pragmas of the programming model, and lowers them to corresponding calls of the runtime system (discussed in Section 4).…”

Section: Programming Modelmentioning

confidence: 99%

Exploiting Significance of Computations for Energy-Constrained Approximate Computing

Vassiliadis

Chalios

Parasyris

et al. 2016

Int J Parallel Prog

Self Cite

View full text Add to dashboard Cite

Approximate execution is a viable technique for environments with energy constraints, provided that applications are given the mechanisms to produce outputs of the highest possible quality within the available energy budget. This paper introduces a framework for energy-constrained execution with controlled and graceful quality loss. A simple programming model allows developers to structure the computation in different tasks, and to express the relative importance of these tasks for the quality of the end result. For non-significant tasks, the developer can also supply less costly, approximate versions. The target energy consumption for a given execution is specified when the application is launched. A significance-aware runtime system employs an application-specific analytical energy model to decide how many cores to use for the execution, the operating frequency for these cores, as well as the degree of task approximation, so as to maximize the quality of the output while meeting the user-specified energy constraints.Evaluation on a dual-socket 16-core Intel platform using 9 kernels and applications shows that the proposed framework performs very close to an oracle always selecting the optimal configuration, both in terms of energy efficiency and quality of results. Also, a comparison with loop perforation (a well-known compile-time approximation technique), shows that the proposed framework results in significantly higher quality for the same energy budget.

show abstract

“…We use compiler pragmas compatible with the Myrmics runtime system, which will be presented in detail in chapter 5. We use a sourceto-source compiler [118] to translate the pragma-annotated C code to plain C code with calls to the Myrmics runtime system interface. We present this interface in the next section (figure 3.3).…”

Section: Code Examplementioning

confidence: 99%

“…Figure 3.3 lists the Application Programming Interface (API) which connects our programming model to a runtime system, such as Myrmics. A programmer may either use this interface directly to write applications, or employ a compiler such as SCOOP [118]. We give a description of the interface here; formal semantics and proofs for determinism and serial equivalence can be found in our previous work [94].…”

Section: Application Programming Interface (Api)mentioning

confidence: 99%

“…Dynamic Outof-Order Java [38] is a recent example of such a language, which performs many static optimizations and also uses heap examiners at runtime, to resolve cases that are ambiguous by the static analysis. Myrmics does not rely on static analysis techniques, but is still able to use compiler hints to exclude certain task arguments if the compiler marks them as SAFE -our modified SCOOP compiler [118] can provide such hints to Myrmics.…”

Section: Static Dependency Analysismentioning

confidence: 99%

See 1 more Smart Citation

Myrmics

Lyberis¹

View full text Add to dashboard Cite

The end of the processor performance race in the start of the current century signaled the beginning of the multicore era. To harness the benefits of multiple CPU cores for a single application, programmers must now use parallel programming models. Semiconductor trends hint that processors within the next decade will manage to integrate hundreds of cores on a single chip; the architecture will be heterogeneous, with few strong (and power-hungry) cores and many weak (and power-efficient) ones; caches will be less or not at all coherent. As the new manycore era approaches, finding a productive and efficient programming model able to scale on such architectures is a major challenge.Dependency-aware, task-based programming models have gained a significant following. The programmer provides a serial program, split into small functions (tasks) that run to completion, along with information about the data on which the tasks will operate. A runtime system analyzes the dependencies and schedules and executes the tasks in parallel. Despite their increasing popularity, these programming models are not ready to scale to emerging manycore architectures, as they primarily target today's homogeneous, cachecoherent multicores. Their runtime implementations appear to be neither scalable, nor suitable for heterogeneous, less coherent architectures.Our thesis delves into the parallel programming challenges that lie ahead in the coming decade. We consider two major problems. First, how should a parallel runtime system be designed, in order to be able to scale well on a manycore processor ten years from now? And second, how can we implement and evaluate such runtime system designs, since such manycore processors are not currently available?Towards the first problem, we enhance an existing task-based model to support nested parallelism and pointer-based, irregular data structures. We then design and implement Myrmics, a runtime system that implements this programming model. Myrmics is specifically designed to run on future, heterogeneous, non-coherent processors and to scale well using novel, distributed algorithms and policies for hierarchical memory management, dependency analysis and task scheduling. Our experimental results reveal that Myrmics scales well compared to reference, hand-tuned MPI baselines, while automatic parallelization overheads remain modestly low (10-30%). We verify that many of our proposed algorithms and policies are promising.Towards the second problem, we create a heterogeneous 520-core FPGA prototype modeled faithfully after current predictions for manycore processors. We use it to evaluate the Myrmics runtime system. The FPGA prototype is based on Formic, a new printed circuit board that we design specifically for scalable systems. We estimate that our prototype runs code 50,000 faster than software simulators for similar core counts.v Hellas (FORTH), and was financially supported by a FORTH-ICS scholarship, including funding by the European Union 7 th Framework Programme [FP7/2007[FP7/ -2013, under the EN-...

show abstract

Inference and Declaration of Independence in Task-Parallel Programs

Cited by 4 publications

References 32 publications

Myrmics: Scalable, Dependency-aware Task Scheduling on Heterogeneous Manycores

Myrmics: Scalable, Dependency-aware Task Scheduling on Heterogeneous Manycores

Exploiting Significance of Computations for Energy-Constrained Approximate Computing

Myrmics

Contact Info

Product

Resources

About