TaskUniVerse: A Task-Based Unified Interface for Versatile Parallel Execution

TL;DR

TaskUniVerse introduces a unified programming interface that enables seamless, framework-agnostic task-based parallel programming across diverse hardware architectures, enhancing portability and flexibility.

Contribution

It proposes a common interface for various task-based parallel frameworks, simplifying development and promoting interoperability without modifying existing programs.

Findings

Successfully ran matrix operations across multiple frameworks

Framework cooperation configured externally without code changes

Enhanced program portability and flexibility

Abstract

Task based parallel programming has shown competitive outcomes in many aspects of parallel programming such as efficiency, performance, productivity and scalability. Different approaches are used by different software development frameworks to provide these outcomes to the programmer, while making the underlying hardware architecture transparent to her. However, since programs are not portable between these frameworks, using one framework or the other is still a vital decision by the programmer whose concerns are expandability, adaptivity, maintainability and interoperability of the programs. In this work, we propose a unified programming interface that a programmer can use for working with different task based parallel frameworks transparently. In this approach we abstract the common concepts of task based parallel programming and provide them to the programmer in a single programming interface uniformly for all frameworks. We have tested the interface by running programs which implement matrix operations within frameworks that are optimized for shared and distributed memory architectures and accelerators, while the cooperation between frameworks is configured externally with no need to modify the programs. Further possible extensions of the interface and future potential research are also described.

Full text

1 Introduction

Task based parallel programming has experienced a great increase in the past decade due to its competitive outcomes in performance and productivity. The key to success for task based approaches is the abstract view of a program as a set of operations and data. This abstraction allows for programs to be written sequentially using tasks and data whenever an operation is to be performed on program variables/identifiers. When such a program runs, the tasks corresponding to the operations in the program are submitted to the background task-based framework run-time system where they are scheduled for parallel execution. This separation of a written program and its underlying tasks, enables the providers of the task-based frameworks to use different approaches for finding the optimal solution to the scheduling problem of running the tasks on the available computing resources.

Different techniques are provided by task based programming frameworks to the programmer for writing programs. The StarPU [5] and OmpSs [10] frameworks extend the C compiler and allow the programmer to use compiler directives to define C functions as tasks kernels and describe their data dependencies. The PaRSEC [9, 11] framework provides tools and utilities to analyze a program written in a special language that describes tasks and data dependencies and us es a source to source compiler to translate the optimal solution into a C code for compilation. The DuctTeip [22], Chunks and Tasks [17] and also StarPU [2] frameworks provide Application Programming Interface (API) for defining data and tasks to run in a distributed memory environment. The SuperGlue framework [19] provides a headers only C++ library for creating tasks and running them on multi-core processors.

These frameworks have individually shown very good results in terms of performance, scalability and productivity and in a wide spectrum of scientific applications such as solving partial differential equations (PDE) [20], N-Body problems using Fast Multipole Method (FMM) [3, 13, 21], simulating stochastic discrete events [6, 7], Conjugate Gradient method [4], Finite Element Method (FEM) applications [16], chemistry applications [12], seismic applications [15] and image processing [8]. They have also shown the feasibility and benefits of using task based approaches for sparse data structures, [14, 18].

There are also attempts to join pairs of the task based frameworks to combine benefits of both. The StarPU and PaRSEC frameworks joined to provide task parallelism in clusters of heterogeneous processors [1, 14]. The DuctTeip and SuperGlue frameworks joined [22] to implement hierarchical task submission and execution in hybrid distributed and shared memory environments.

While these achievements seem promising for using task based programming models, the choice of a proper task based framework may still be risky when impacts on legacy software due to software and hardware changes may occur due to differences in framework implementations.

In this paper, we address these issues by proposing a unified task based programming (UTP) model in which any number of task based frameworks can be used to run a single application in many parallel environments. This section continues with explaining the motivation for designing such a programming model. The overview, implementation and programming of the UTP model are described in Sections 2.1–2.3. Section 3 shows the performance results of executing a Cholesky factorization program in different parallel computing environments. The last section is devoted to discussion and conclusions.

1.1 Motivation

The number of applications that use task based programming approaches is increasing and more attempts to join two or more task based frameworks to exploit different advantages can be foreseen. These achievements for the task based parallel programming approaches encourage the application domain scientists to see that the solution of the problems they are trying to solve can be implemented in an efficient and scalable way on thousands of processors. However, choosing frameworks for implementing solutions for a specific application domain is still a vital decision for the expert end users in that domain.

The basic factors influencing the choice of framework(s) are richness and flexibility. When needs of a scientific application span a wide spectrum of software and hardware varieties, it becomes hard or impossible to find a single framework to address them. Also the investment of developing an application even on top of a mixture of frameworks has to be secured against probable risks of future changes in underlying software and hardware. In this paper we show how these issues can be addressed by the UTP model through a unified task programming interface.

2 The UTP Model

2.1 Overview of the UTP Model

The UTP programming model is designed to provide an abstraction for common structures and behaviors of the task based frameworks mentioned above. In this abstract view, all the operations performed by a program on its data are replaced by tasks and special data types (e.g., handles or descriptors) representing the program data. Instead of running the operations immediately, the corresponding tasks are submitted to the frameworks’ runtime where their dependencies are tracked and ready tasks are executed in parallel. Actual kernel computations of a ready task are performed through call back mechanisms which are introduced to the frameworks at task creation.

In order to have a single interface for cooperation, the UTP model requires the frameworks to implement predefined interfaces for data definition and task creation, submission, execution and completion. These interfaces unify the cooperation of UTP with any other compliant framework via conversations of generic data and tasks regardless of the concrete instances inside the framework. A central dispatcher in the UTP model orchestrates the flow of tasks and data between the program and frameworks by connecting the interfaces of one framework to another. The dispatcher submits tasks to the frameworks and they will notify the dispatcher when the tasks are ready to execute or finished.

The UTP model divides the software stack into three layers, as shown in Fig. 1(b), where the UTP interface in the middle decouples the application layer at the top from the task based frameworks at the bottom which in turn hide the technical details of parallel programming for the underlying hardware. In the UTP model, the taskified versions of the operations are provided by the middle layer to the application layer via ordinary subroutines while on the other side of the middle layer, the generic tasks move back and forth to the frameworks or their UTP compliant wrappers. Therefore, the UTP at middle layer translates program operations to tasks and data and distributes them properly to available task based frameworks through a generic interface.

Different task flows between dispatcher and task based frameworks can be configured in the UTP model by specifying which two interfaces of frameworks are to be interconnected via the dispatcher. For example, the task-execution interface of one framework can be connected to the task-creation (submission) interface of another to enable hierarchical task management in which, when tasks get ready to execute at higher levels, they split into child tasks and are submitted to the framework at the next level of the hierarchy. This configurable task flow graph between the program and the wrappers allows a single program to run in different parallel computing environments by different task based frameworks.

2.2 Implementation of the UTP Model

The UTP model provides the necessary data structures and interfaces to the application layer for defining data and performing operations on them. These interfaces also enable partitioning the data into parts and splitting an operation into child tasks. Usages of data definition and partitioning interfaces by the program are propagated to all the task based frameworks to manage their own internal data types.

For running a program using various frameworks, the UTP model also contains implemented wrappers around the SuperGlue, StarPU and DuctTeip task based frameworks, Fig. 1(b). There are also cpuBLAS and cuBLAS wrappers around Basic Linear Algebra Subprograms (BLAS) and Linear Algebra PACKage (LAPACK) libraries for CPU and GPU devices, respectively, that can be used in the task flow graph for running the actual computations of tasks on the corresponding devices. The tasks submitted to these two wrappers are immediately executed and their completions are reported back to the dispatcher.

Figure 1(a) shows some examples of possible and practical configurations of task flow graphs $G_{1}$– $G_{4}$ for running a program whose operations on data are totally decomposable into BLAS subroutines. The edge from the program to the dispatcher $D$ is common for all the graphs and is not shown in the figure. The flow of tasks and data between the dispatcher $D$ and the wrappers can be configured to determine the hierarchy of data and tasks and the corresponding responsible frameworks.

The nodes in the graphs shown in Fig. 1(a) are the dispatcher $D$ and the wrappers around the task based frameworks. A directed edge from the dispatcher $D$ to node $w$ denotes that the tasks coming from the program to the dispatcher are forwarded to wrapper $w$. The edges between wrappers $w_{1}$ and $w_{2}$ show that ready tasks at $w_{1}$ are split into sub tasks by the dispatcher and are submitted to $w_{2}$, and task completions at $w_{2}$ are reported back to $w_{1}$ via the dispatcher.

Using configurations $G_{1}$– $G_{4}$ the program can run in distributed-/shared- memory and heterogeneous (with accelerators) computing environments. Using the $G_{1}$ configuration, it can run sequentially on one CPU since tasks submitted to the dispatcher are forwarded to and immediately executed by the cpuBLAS wrapper. In the $G_{2}$ configuration, the same program can run on multi-core systems using the SuperGlue wrapper for managing submitted tasks on available cores and using the BLAS library wrapper for running the tasks on individual cores. The $G_{3}$ configuration is constructed by adding the DuctTeip wrapper on top of several wrappers and enables the program to run in a cluster of computing nodes where DuctTeip is managing data and tasks in distributed memory environments. In the $G_{4}$ configuration, the program can run in a cluster of computing nodes with heterogeneous CPU/GPU processors using StarPU for managing tasks on both CPU and GPU.

2.3 Programming in the UTP Model

In the three layers view of the UTP model, the required programming at the bottom layer is already done in the UTP framework and provided as wrappers around some existing and frequently used task based frameworks. Further development of wrappers can be performed by framework providers or users by implementing the unified interface.

The programming at the middle layer, consists of implementing the translation and splitting of operations into tasks or sub tasks. This can be done by implementing predefined interfaces (e.g., the split method of an operation object) which will be used by the dispatcher during the program execution. User friendly functions can hide the technical details of the task and operations from the the programmer at the application layer. The programming at the application layer consists of defining data and their partitions and calling functions provided by the technical layer to manipulate the data.

The programming in the UTP model is exemplified by implementing a block Cholesky matrix factorization called POTRF (POsitive definite matrix TRiangular Factorization) in BLAS/LAPACK terminology. The program at the application layer (shown in Fig. 2(a), lines 1–17) defines the input/output matrix A and its partitioning in two subsequent hierarchical levels (b1 and b2) with parameters read from the command line and passes it to the utp_cholesky function which is implemented in the technical layer (Fig. 2(a), lines 19–25).

The <name>Task objects in Figs. 2(a) and 2(b) are subclasses of a generic task class in the UTP model whose constructors accept an Operation object, a pointer to the parent task and data arguments of the task. The created POTRFTask in the utp_cholesky function (Fig. 2(a), line 22) corresponds to the operation object upotrfo with no parent task.

The Operation objects in the UTP model are responsible for splitting an operation into child tasks that manipulate the partitions of the parent task’s data arguments. Figure 2(b) shows the split method of the upotrfo operation which in nested loops manipulates the partitions of input argument A using the indexing interface A(r,c) to access the partition at row r and column c of A.

At the lowest level of the task hierarchy, when a task is submitted by the dispatcher to <cpu/cu>BLAS wrappers the run method of the task’s operation is invoked where the BLAS/LAPACK routine is immediately called and task completion is reported back to the dispatcher, as shown in Fig. 2(a) lines 27–37.

3 Experiments

To demonstrate the productivity gained by the UTP programming model, the Cholesky matrix factorization algorithm is implemented and executed with different matrix sizes on different parallel computing resources. In all these experiments the program at the application layer is written once and executed in different configurations for different underlying parallel hardware.

These programs were executed in the HPC2N computer cluster Kebnekaise using 32 nodes, each with two Intel Xeon E5-2690v4 CPU with 14 cores and with two NVIDIA K80 with 4992 cores. The programs are all written in C++, compiled with Intel compiler 17.0.1 and Intel MPI version 2017 Update 1 and use Intel MKL for BLAS/LAPACK routines.

The Cholesky factorization program is executed in multi-core with or without GPU and multi-node computing environments. The SuperGlue, DuctTeip and StarPU frameworks are used with the UTP and the non-UTP models to compare performance when running the program in these environments, see Figs. 3(a) and 3(b). In Fig. 3(a) different configurations ($C_{1}$–$C_{6}$) of frameworks are used for running the Cholesky factorization program in one computing node of multi-cores with/without GPUs. In the configurations $C_{1}$–$C_{3}$ matrices up to 30000$\times$30000 elements are factorized using the StarPU framework ($C_{1}$), the StarPU wrapper within UTP ($C_{2}$) and the SuperGlue wrapper within UTP ($C_{3}$). For factorizing larger matrices in one computing node, parts of the computations are executed in the GPUs by using the StarPU framework ($C_{4}$), the StarPU wrapper within UTP ($C_{5}$) and the DuctTeip wrapper and StarPU wrapper within UTP ($C_{6}$). The StarPU framework in configuration $C_{4}$ uses recursive data partitioning and can proceed to larger matrices up to 50000$\times$50000 elements. In configuration $C_{5}$, the StarPU wrapper is used within UTP without hierarchical data partitioning, and hence cannot factorize larger matrices. However, in configuration $C_{6}$ adding the DuctTeip wrapper to configuration $C_{5}$ results in hierarchical data partitioning and enables factorization of larger matrices with the same performance as with the $C_{5}$ configuration.

In Fig. 3(b), the performance of different frameworks is compared for Cholesky factorization of matrices in a distributed memory environment. The factorization is performed by the StarPU framework ($C_{7}$), the DuctTeip and StarPU wrappers within UTP ($C_{8}$) and the DuctTeip and SuperGlue wrappers within UTP ($C_{9}$). All the configurations perform hierarchical data partitioning for splitting the factorization into smaller data blocks and as shown in the figure, using frameworks within UTP exhibits better performance than the StarPU only configuration.

These experiments demonstrate that using the UTP model, the single program at the application layer written once and run in several parallel computing environments, not only is independent of any individual framework, but also can attain the most favorable throughput from a customizable mixture of available frameworks.

4 Conclusions and Future Works

We have designed, implemented and verified the UTP model that unifies the cooperation interface between task based frameworks. This interface decouples the frameworks from the program that uses them which enables the program to run in different parallel computing environment, allows independent software development at technical layers and makes the program tolerant to the future changes in the underlying hardware. The configurable task flows in the UTP model allows a program to use a mixture of different frameworks to meet various needs of computations on different computing resources.

Acknowledgments

Thanks to Assoc. Prof. Elisabeth Larsson111http://www.it.uu.se/katalog/bette for her valuable comments on improving the quality of this paper. The computations were performed on resources provided by SNIC through the resources provided by High Performance Computing Center North (HPC2N) under project SNIC2016-7-34.