A dependency-aware task-based programming environment for multi-core architectures

Perez, Josep M.; Badía, Rosa M.; Labarta, Jesús

doi:10.1109/clustr.2008.4663765

Cited by 188 publications

(166 citation statements)

References 22 publications

(27 reference statements)

Supporting

Mentioning

164

Contrasting

Unclassified

Order By: Relevance

“…In their approach, the compiler generates code that scans and enumerates all vertices of the DAG at the beginning of the run-time execution. This has the same drawbacks as approaches, such as StarSS [21] and TBlas [24], that rely on pseudo-execution of the serial loops at run-time to dynamically discover dependencies between kernels. The overhead grows with the problem size and the scheduling is either centralized of replicated.…”

Section: Related Workmentioning

confidence: 98%

From Serial Loops to Parallel Execution on Distributed Systems

Bosilca

Bouteiller

Danalis

et al. 2012

Euro-Par 2012 Parallel Processing

View full text Add to dashboard Cite

Abstract. Programmability and performance portability are two major challenges in today's dynamic environment. Algorithm designers targeting efficient algorithms should focus on designing high-level algorithms exhibiting maximum parallelism, while relying on compilers and runtime systems to discover and exploit this parallelism, delivering sustainable performance on a variety of hardware. The compiler tool presented in this paper can analyze the data flow of serial codes with imperfectly nested, affine loop-nests and if statements, commonly found in scientific applications. This tool operates as the front-end compiler for the DAGuE run-time system by automatically converting serial codes into the symbolic representation of their data flow. We show how the compiler analyzes the data flow, and demonstrate that scientifically important, dense linear algebra operations can benefit from this analysis, and deliver high performance on large scale platforms.

show abstract

Section: Related Workmentioning

confidence: 98%

From Serial Loops to Parallel Execution on Distributed Systems

Bosilca

Bouteiller

Danalis

et al. 2012

Euro-Par 2012 Parallel Processing

View full text Add to dashboard Cite

show abstract

“…The idea is an extension to our previous work on speculative updates to shared memory locations using Software Transactional Memory (STM) [7]. We implement our idea in StarSs [10], a task based programming model with support for heterogeneity. StarSs has implementations for widely used multi-core architectures such as Symmetric Multiprocessors (SMP), the Cell Broadband Engine (Cell B./E.…”

Section: Listing 1: Example Pseudo Codementioning

confidence: 99%

Loop level speculation in a task based programming model

Gayatri

Badía

Aygaude

2013

20th Annual International Conference on High Performance Computing

View full text Add to dashboard Cite

Abstract-Uncountable loops (such as while loops in C) and if-conditions are some of the most common constructs in programming. While-loops are widely used to determine the convergence in linear algebra algorithms or goal finding problems from graph algorithms, to name a few. In general whileloops are used whenever the loop iteration space, the number of iterations a loop executes is unknown. Usually in while-loops, the execution of the next iteration is decided inside the current loop iteration (i.e. the execution of iteration i depends on the values computed in iteration i-1). This precludes their parallel execution in today's ubiquitous multi-core architectures. In this paper a technique to speculatively create parallel tasks from the next iterations before the current one completes is proposed. If consecutive loop-iterations are only control dependent, then multiple iterations can be executed simultaneously; later in the execution path, the runtime system will decide to either commit the results of such speculatively executed iterations or undo the changes made by them. Data dependences within or between non-speculative and speculative work are honored to guarantee correctness. The proposed technique is implemented in SMPSs, a task-based dataflow programming model for shared-memory multiprocessor architectures. The approach is evaluated on a set of applications from graph algorithms and linear algebra. Results are promising with an average increase in the speedup of 1.2x with 16 threads when compared to non speculative execution of the applications. The increase in the speedup is significant, since the performance gain is achieved over an already parallelized version of the benchmarks.

show abstract

“…We force the scheduler to run each task version at least λ times during the initial learning phase 4 . Once all tasks versions belonging to the same group of data set sizes have been run at least λ times, we consider that the scheduler has enough reliable information and it switches to the reliable information phase 5 for the given group of data set size. This means that the scheduler can have different criteria for the ready tasks that picks from the task graph, depending whether their corresponding group of data set size has enough reliable information or not.…”

Section: B Runtime Implementationmentioning

confidence: 99%

“…Programming models should be able to support this heterogeneity and hierarchy in such a way that the application is unaware of the underlying hardware and that can dynamically adapt to it. The OmpSs programming model combines ideas from OpenMP [4] and StarSs [5]: it enhances OpenMP with support for irregular and asynchronous parallelism and heterogeneous architectures. It incorporates data-flow concepts that allow the compiler/runtime to automatically move data as necessary and perform different kinds of optimizations.…”

Section: Introductionmentioning

confidence: 99%

Self-Adaptive OmpSs Tasks in Heterogeneous Environments

Planas

Badía

Ayguadé

et al. 2013

2013 IEEE 27th International Symposium on Parallel and Distributed Processing

Self Cite

View full text Add to dashboard Cite

Abstract-As new heterogeneous systems and hardware accelerators appear, high performance computers can reach a higher level of computational power. Nevertheless, this does not come for free: the more heterogeneity the system presents, the more complex becomes the programming task in terms of resource management.OmpSs is a task-based programming model and framework focused on the runtime exploitation of parallelism from annotated sequential applications. This paper presents a set of extensions to this framework: we show how the application programmer can expose different specialized versions of tasks (i.e. pieces of specific code targeted and optimized for a particular architecture) and how the system can choose between these versions at runtime to obtain the best performance achievable for the given application. From the results obtained in a multi-GPU system, we prove that our proposal gives flexibility to application's source code and can potentially increase application's performance.

show abstract

A dependency-aware task-based programming environment for multi-core architectures

Cited by 188 publications

References 22 publications

From Serial Loops to Parallel Execution on Distributed Systems

From Serial Loops to Parallel Execution on Distributed Systems

Loop level speculation in a task based programming model

Self-Adaptive OmpSs Tasks in Heterogeneous Environments

Contact Info

Product

Resources

About