Polytasks: A Compressed Task Representation for HPC Runtimes

Orozco, Daniel; Garcia, Elkin; Pavel, Robert S.; Khan, Rishi; Gao, Guang R.

doi:10.1007/978-3-642-36036-7_18

Cited by 5 publications

(2 citation statements)

References 12 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Similarly, Index Launches [25] can automatically compact several task launches in a loop without need for explicit annotation. Polytasks [26] also merge several similar tasks when they are created at the same time, provided tasks are managed through queues. These approaches reduce the total number of tasks created by an application.…”

Section: A Task Management Overheadmentioning

confidence: 99%

Optimizing Iterative Data-flow Scientific Applications using Directed Cyclic Graphs

Álvarez

Beltrán

2023

IEEE Access

View full text Add to dashboard Cite

Data-flow programming models have become a popular choice for writing parallel applications as an alternative to traditional work-sharing parallelism. They are better suited to write applications with irregular parallelism that can present load imbalance. However, these programming models suffer from overheads related to task creation, scheduling and dependency management, limiting performance and scalability when tasks become too small. At the same time, many HPC applications implement iterative methods or multi-step simulations that create the same directed acyclic graphs of tasks on each iteration. By giving application programmers a way to express that a specific loop is creating the same task pattern on each iteration, we can create a single task DAG once and transform it into a cyclic graph. This cyclic graph is then reused for successive iterations, minimizing task creation and dependency management overhead. This paper presents the taskiter, a new construct we propose for the OmpSs-2 and OpenMP programming models, allowing the use of directed cyclic task graphs (DCTG) to minimize runtime overheads. Moreover, we present a simple immediate successor locality-aware heuristic that minimizes task scheduling overhead by bypassing the runtime task scheduler. We evaluate the implementation of the taskiter and the immediate successor heuristic in 8 iterative benchmarks. Using small task granularities, we obtain a geometric mean speedup of 2.56x over the reference OmpSs-2 implementation, and a 3.77x and 5.2x speedup over the LLVM and GCC OpenMP runtimes, respectively.INDEX TERMS taskiter, data-flow programming, ompss-2, openmp, iterative applications

show abstract

Section: A Task Management Overheadmentioning

confidence: 99%

Optimizing Iterative Data-flow Scientific Applications using Directed Cyclic Graphs

Álvarez

Beltrán

2023

IEEE Access

View full text Add to dashboard Cite

show abstract

“…The use of process replication for reliability has been demonstrated previously (Ferreira et al, 2011). Task abstractions for manycore architectures that include compressed task representation have been shown to improve efficiency and reduce the queuing overhead Orozco et al (2011). Browsers and runtime systems in mobile devices, both, depend on the capability to launch several short-lived processes in a short time.…”

Section: Related Workmentioning

confidence: 99%

Optimizing process creation and execution on multi-core architectures

Kulkarni

Ionkov

Lang

et al. 2013

The International Journal of High Performance Computing Applica

View full text Add to dashboard Cite

The execution of a single process multiple data (SPMD) application involves running multiple instances of a process with possibly varying arguments. With the widespread adoption of massively multicore processors, there has been a focus towards harnessing the abundant compute resources effectively in a power-efficient manner. Although much work has been done towards optimizing distributed process launch using hierarchical techniques, there has been a void in studying the performance of spawning processes within a single node. Reducing the latency to spawn a new process locally results in faster global job launch. Further, emerging dynamic and resilient execution models are designed on the premise of maintaining process pools for fault isolation and launching several processes in a relatively shorter period of time. Optimizing the latency and throughput for spawning processes would help improve the overall performance of runtime systems, allow adaptive process-replication reliability and motivate the design and implementation of process management interfaces in future manycore operating systems. In this paper, we study the several limiting factors for efficient spawning of processes on massively multicore architectures. We have developed a library to optimize launching multiple instances of the same executable. Our microbenchmarks show a 20–80% decrease in the process spawn time for multiple executables. We further discuss the effects of memory locality and propose NUMA-aware extensions to optimize launching processes with large memory-mapped segments including dynamic shared libraries. Finally, we describe vector operating system interfaces for spawning a batch of processes from a given executable on specific cores. Our results show a speedup of a factor of 40–50 over the traditional method of launching new processes using fork and exec system calls.

show abstract

TIDeFlow: The Time Iterated Dependency Flow Execution Model

Orozco

Garcia

Pavel

et al. 2011

2011 First Workshop on Data-Flow Execution Models for Extreme Scale Computing

Self Cite

View full text Add to dashboard Cite

The many-core revolution brought forward by recent advances in computer architecture has created immense challenges in the writing of parallel programs for High Performance Computing (HPC). Development of parallel HPC programs remains an art, and a universal doctrine for synchronization, scheduling and execution in general has not been found for many-core/multi-core architectures. These issues are exacerbated by the popularity of traditional execution models derived from the serial-programming school of thought. Previous solutions for parallel programming, such as OpenMP, MPI and similar models, require significant effort from the programmer to achieve high performance.This paper provides an introduction to the Time Iterated Dependency Flow (TIDeFlow) model, a parallel execution model inspired by dataflow, and a description of its associated runtime system. TIDeFlow was designed for efficient development of high performance parallel programs for many-core architectures.The TIDeFlow execution model was designed to efficiently express (1) parallel loops, (2) dependencies (data, control or other) between parallel loops and (3) to allow composability of programs.TIDeFlow is a work in progress. This paper presents an introduction to the TIDeFlow execution model and shows examples and preliminary results to illustrate the qualities of TIDeFlow.The main contributions of this paper are:1. A brief description of the TIDeFlow execution model, and its programming model, 2. A description of the implementation of the TIDeFlow runtime system and its capabilities and 3. Preliminary results showing the suitability of TIDeFlow to express parallel programs in many-core archiPermission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee.

show abstract

Polytasks: A Compressed Task Representation for HPC Runtimes

Cited by 5 publications

References 12 publications

Optimizing Iterative Data-flow Scientific Applications using Directed Cyclic Graphs

Optimizing Iterative Data-flow Scientific Applications using Directed Cyclic Graphs

Optimizing process creation and execution on multi-core architectures

TIDeFlow: The Time Iterated Dependency Flow Execution Model

Contact Info

Product

Resources

About