Francisco Heron de Carvalho Junior

A case study on expressiveness and performance of component-oriented parallel programming

Component-oriented programming has been applied to address the requirements of large-scale applications from computational sciences and engineering that present high performance computing (HPC) requirements. However, parallelism continues to be a challenging requirement in the design of CBHPC (Component-Based High Performance Computing) platforms. This paper presents strong evidence about the efficacy and the efficiency of HPE (Hash Programming Environment), a CBHPC platform that provides full support for parallel programming, on the development, deployment and execution of numerical simulation code onto cluster computing platforms.

Contextual abstraction in a type system for component-based high performance computing platforms

HTS (Hash Type System) is a type system designed for component-based high performance computing (CBHPC) platforms, aimed at reconciling portability, modularity by separation of concerns, a high-level of abstraction and high performance. Portability and modularity are properties of component-based systems that have been extensively validated. For improving the performance of HPC applications, HTS introduces an automated approach for dynamically discovering, loading and binding parallel components tuned for the characteristics of the parallel computing platforms where the application will execute. To do so, it is based on contextual abstraction, where the performance of components that encapsulate parallel computations, communication patterns and data structures may be tuned according to the features of parallel computing platforms and the application requirements. In turn, for providing a higher level of abstraction in parallel programming, HTS supports an expressive approach for skeleton-based programming. A study of the safety properties of HTS using a calculus of component composition has provided solid foundations for the design of configuration languages for the safe specification and deployment of parallel components. The features of HTS are validated with three case studies that exercise the programming techniques behind contextual abstraction, including skeletons and performance tuning. HTS is a type system for automatic discovery of components in CBHPC platforms.HTS implements contextual abstraction for component discovery in CBHPC platforms.Contexts define component assumptions about their execution platform and application.HTS supports parallel programming with skeletons.We provide a set of formal proofs about safety properties of HTS.

On the Performance of Multidimensional Array Representations in Programming Languages Based on Virtual Execution Machines

This paper evaluates the performance of virtual execution machines (VM) of the CLI and JVM standards for the common approaches to represent multidimensional arrays in high performance computing applications. In particular, it shows which representation is the best for each virtual machine implementation, showing that the choices may be surprisingly contradictory, even with respect to previous results of other works on performance evaluation of VMs.

A categorical characterization for the compositional features of the # component model

The # programming model attempts to address the needs of the high performance computing community for new paradigms that reconcile efficiency, portability, abstraction and generality issues on parallel programming for high-end distributed architectures. This paper provides a semantics for the compositional features of # programs, based on category theory.

GPU-accelerated backtracking using CUDA Dynamic Parallelism: GPU-Accelerated Backtracking Using CUDA Dynamic Parallelism

New GPGPU technologies, such as CUDA Dynamic Parallelism (CDP), can help dealing with recursive patterns of computation, such as divide‐and‐conquer, used by backtracking algorithms. In this paper, we propose a GPU‐accelerated backtracking algorithm using CDP that extends a well‐known parallel backtracking model. The search starts on CPU, processing the search tree until a first cutoff depth. Based on this partial backtracking tree, the algorithm analyzes the memory requirements of subsequent kernel generations. The proposed algorithm performs no dynamic allocation of memory on GPU, unlike related works from the literature. The proposed algorithm has been extensively tested using the N‐Queens Puzzle problem and instances of the Asymmetric Traveling Salesman Problem (ATSP) as test‐cases. The proposed CDP algorithm may, under some conditions, outperform its non‐CDP counterpart by a factor up to 25. But, it may also be up to twice slower. The CDP‐based implementation has much better worst case execution times and makes algorithms performance less dependent on the tuning of parameters. Compared to other CDP‐based strategies from the literature, the proposed algorithm is on average 8× faster. The proposed algorithm is also hybridized with another CDP‐based strategy from the literature. The combination of strategies is in average 4.5× faster than the related strategy. We also identify some difficulties, limitations, and bottlenecks concerning the CDP programming model which may be useful for helping potential users.

A GPU-Based Backtracking Algorithm for Permutation Combinatorial Problems

This work presents a GPU-based backtracking algorithm for permutation combinatorial problems based on the Integer-Vector-Matrix (IVM) data structure. IVM is a data structure dedicated to permutation combinatorial optimization problems. In this algorithm, the load balancing is performed without intervention of the CPU, inside a work stealing phase invoked after each node expansion phase. The proposed work stealing approach uses a virtual n-dimensional hypercube topology and a triggering mechanism to reduce the overhead incurred by dynamic load balancing. We have implemented this new algorithm for solving instances of the Asymmetric Travelling Salesman Problem by implicit enumeration, a scenario where the cost of node evaluation is low, compared to the overall search procedure. Experimental results show that the dynamically load balanced IVM-algorithm reaches speed-ups up to 17\(\times \) over a serial implementation using a bitset-data structure and up to 2\(\times \) over its GPU counterpart.

A Platform of Scientific Workflows for Orchestration of Parallel Components in a Cloud of High Performance Computing Applications

HPC Shelf is a proposal of a cloud computing platform for development, deployment and execution of component-based HPC applications with large-scale parallel processing requirements. Through components, it addresses the challenge of dealing with heterogeneous resources in high-end parallel computing systems, including both software and hardware. This paper introduces SAFe, a framework for deriving HPC Shelf applications, and SAFeSWL, a scientific workflow language for describing the architectural and orchestration parts of parallel computing systems deployed by HPC Shelf applications through SAFe.

Derivation and Verification of Parallel Components for the Needs of an HPC Cloud

Cloud computing platforms are considered a promising approach for provision of High Performance Computing services. HPC Storm is an ongoing research project that is proposing a component-oriented view of HPC resources in a cloud, towards the development and provision of large-scale parallel computing systems. In this context, a system of contracts have been proposed for representing functional and non-functional properties of components. This paper is interested in evaluating the use of the Circus specification language for specifying the functional and behavioral subset of computational component contracts. For that, a process is proposed for their development and some case studies with real programs in the HPC domain are used to validate it in practice.

Contextual Abstraction in a Type System for Component-Based High Performance Computing Platforms

This paper presents the formalization of HTS (Hash Type System), a type system for component-based high performance computing (CBHPC) platforms. HTS aims at supporting an automated approach for dynamic discovering, loading and binding of parallel components. HTS gives support for building multiple implementations of abstract components, the performance of which are tuned according to the specific features of high-end distributed-memory parallel computing platforms and the application requirements, through context abstraction.

Component-Based Refactoring of Parallel Numerical Simulation Programs: A Case Study on Component-Based Parallel Programming

Component-based programming has been applied to address the requirements of large scale applications from sciences and engineering with high performance computing (HPC) requirements. However, parallelism has been poorly supported in usual component infrastructures. This paper evidences the efficacy of an HPC platform of parallel components for development and execution of numerical simulation code, mostly found in these applications.