Sm@rtConfig: A context-aware runtime and tuning system using an aspect-oriented approach for data intensive engineering applications

Abstract

Distributing the workload upon all available Processing Units (PUs) of a high-performance heterogeneous platform (e.g., PCs composed by CPU–GPUs) is a challenging task, since the execution cost of a task on distinct PUs is non-deterministic and affected by parameters not known a priori. This paper presents Sm@rtConfig, a context-aware runtime and tuning system based on a compromise between reducing the execution time of engineering applications and the cost of tasks' scheduling on CPU–GPUs' platforms. Using Model-Driven Engineering and Aspect Oriented Software Development, a high-level specification and implementation for Sm@rtConfig has been created, aiming at improving modularization and reuse in different applications. As case study, the simulation subsystem of a CFD application has been developed using the proposed approach. These system's tasks were designed considering only their functional concerns, whereas scheduling and other non-functional concerns are handled by Sm@rtConfig aspects, improving tasks modularity. Although Sm@rtConfig supports multiple PUs, in this case study, these tasks have been scheduled to execute on an platform composed by one CPU and one GPU. Experimental results show an overall performance gain of 21.77% in comparison to the static assignment of all tasks only to the GPU.

Introduction

High performance platforms are commonly required for scientific and engineering algorithms to deal appropriately with timing constraints. Desktop-based co-processors, such as many cores Graphics Processing Units (GPUs), have become a cost effective alternative as execution platform to improve performance. As an example, Nvidia has presented its GPU GTX285 that provides a peak performance of 1062 Gflop/s for single precision and 89 Gflop/s for double precision float operations (Nvidia, 2010).

As a consequence, heterogeneous platforms with several types of PUs act in essence as powerful asymmetric multi-core clusters and can handle multiple applications and tasks. This is even intensified with the multi-core CPUs, like the Intel Core2Quad that provides around 100 Gflop/s (Intel, 2010). Therefore, efficiently using all available resources from the PUs is a significant challenge to program applications.

Another challenge is the design of applications that use such a heterogeneous platform. On one hand, distinct PUs may require a specific programming technology, which, on the other hand, may not be supported by all available PUs. To transform the same application's source code into binary code for multiple PUs, an experienced specialist may be required in addition to have development tools available. Virtualization is an example of technique to solve the compatibility problem by adding a layer (i.e., a virtual machine) between the application binary code and the real PU, e.g., Java Virtual Machine. However, this solution leads to a performance penalty, which sometimes cannot be accepted by the target application due to its constraints. Such a situation demands new techniques to raise the design's abstraction level of such applications.

Using high-level representations of the application's structure and behavior allow the refinement of the application's requirements up to achieving its native implementation in the technology(ies) supported by different target PUs. Model-Driven Engineering (MDE) approaches advocate that designers shall use models instead of source code as the main artifact of the design. The system implementation is generated automatically from these models. In this sense, Aspect-Oriented Model-Driven Engineering for Real-Time (AMoDE-RT) systems (Wehrmeister, Freitas, Wagner, & Pereira, 2007) is a MDE approach that uses the Unified Modeling Language (UML),¹ along with its MARTE profile² for specifying real-time systems and concepts of the Aspect Oriented Software Development (AOSD) approach. Modularization and reuse are the main goals of AMoDE-RT approach, since implementations for distinct execution platforms can be obtained from the same application's UML model.

This work extends the AMoDE-RT, more specifically, its aspects framework, by including a modular and reusable runtime system for dynamic scheduling and tuning. In order to take full advantage of the available computing power, a strategy to distribute the application tasks over the available PUs is important. The strategy lies on dynamic scheduling, instead of static scheduling used by OpenCL (Khronos, 2010) or, more specifically, by CUDA (Nvidia, 2010) for Nvidia GPUs (see also Göddeke et al., 2009). This need becomes even more essential when dealing with desktop applications with timing constraints, like the real-time 3D Computational Fluid Dynamics (CFD) systems used as case study and which is applied in several complex engineering applications, such as design of modern cars or airplanes.

The task scheduling problem is considered NP-complete (Garey & Johnson, 1990) and several heuristics have been developed to better meet a good scheduling with little overhead, like, for example, the distinct approaches used by Topcuoglu, Society, you Wu, and Member (2002), Ahmadinia, Bobda, Koch, Majer, and Teich (2004), and Götz and Dittmann (2006) for heterogeneous PUs. However, just very recently, some techniques are starting to be directly applied to platforms containing CPU (eventually multi-core) and multiple GPUs. This paper additionally presents a new strategy to distribute the workload over the CPU and the GPU, being sufficient generic to consider other PUs coupled in a desktop. The dynamic scheduling method is oriented for a set of high-level tasks, like algorithms. It combines a first assignment phase – based on a pre-processing benchmark for acquiring initial tasks performance samples – with a runtime phase that obtains real performance measurements of tasks and feeds a performance database. This way, after the first assignment, the system considers the history presented on the database to perform further assignments for every task, maximizing the applications' performance with little overhead.

In this work, three iterative solvers for Systems of Linear Equations (SLEs) – Jacobi, Red-Black Gauss-Seidel, and Conjugate Gradient – are used by the CFD application and represent the high-level tasks for the scheduling strategy. The solvers have different implementations for the CPU and the GPU (using shared memory and with memory coalescing), as presented in previous work (Binotto et al., 2010).

It is important to mention that, although the GPU is more powerful to deal with those kind of data-intensive tasks, there are many scenarios in which the CPU provides better performance, e.g., when working with multiple applications and tasks with different problem size domains (based on the amount of data to be processed, not known before application execution). The paper presents an example of such a scenario. In a CFD application, a gain of 21.77% in comparison to the static assignment of all tasks to the GPU is achieved, while the scheduling error remains negligible.

The main contribution of this paper is the Sm@rtConfig framework, which provides a dynamic scheduling method for a desktop CPU–GPU platform that is composed of:

• a first assignment phase,

• a runtime profiler that feeds a timing performance database, and

• the runtime assignment phase that performs assignments based on the performance history stored on the database.

The paper is structured as follows: Section 2 presents the design approach based on aspect orientation used for the application specification and implementation phase. Following, Section 3 describes the new scheduling strategies that implement the aspects for one CPU and one GPU and its generalization for multiple PUs. Section 4 presents the real-time computing CFD applications used as case study. Its requirements and specification are discussed along with the obtained experimental results based on a performance analysis over the CPU–GPU platform. The related work focused on both design methods and the scheduling on distributed platforms using the GPU is then presented in Section 5. Finally, conclusions and future research are addressed in Section 6.