Gerson Geraldo H. Cavalheiro

Anahy: a programming environment for cluster computing

This paper presents Anahy, a programming environment for cluster computing. Anahy is presented in terms of its programming interface (API) and its scheduling mechanism. The main features of this environment are the specification of a POSIX thread-based API and the use of dynamic scheduling techniques based on Directed Acyclic Task Graphs (DAG). The main advantage obtained with these features is the dissociation between the description of the concurrency of an application and its parallel execution. The paper examines how Anahy builds a DAG describing the dependencies among tasks at execution time from a multithreaded program and how this DAG is handled by the runtime to apply dynamic scheduling techniques. The paper concludes discussing three case studies of applications developed in the context of Anahy environment.

Kanga: A Skeleton-Based Generic Interface for Parallel Programming

Concurrent programming tools strive to exploit hardware resources as much as possible. Nonetheless, the lack of high level abstraction of such tools often require from the user a reasonable amount of knowledge in order to achieve satisfactory performance requirements as well as they do not prevent error prone situations. In this paper we present Kanga, a framework based on the abstractions of skeletons to provide a generic tool that encapsulate many common parallel patterns. Through two case studies we validate the framework implementation.

Exploiting multithreaded programming on cluster architectures

The development of programs for parallel architectures focusing to achieve high indices of performance is a hard task. The programmer must deal with two classes of problems, one related to describing the application concurrency and data dependencies, and other related to exploiting efficiently the processing resources of the architecture, in order to obtain an efficient implementation for a specific hardware configuration. Since cluster technology allows building parallel computers are highly scalable - particularly in terms of number of nodes, processors and amount of memory - programming and execution levels must be considered independently to achieve performance portability. This paper presents Anahy, an environment for exploiting high performance computing on cluster architectures. It is highlighted the Anahy programming interface and some features of its implementation as well as a performance evaluation.

A user level approach to schedule BoT applications on private clouds

This paper presents a user level approach to schedule tasks generated by bag of tasks (BoT) applications on a private cloud. At this level, the scheduler consolidates the load of the tasks in a given number of virtual machines providing the estimated makespan. We present the proposed algorithm as well as a model for BoT applications and a performance assessment in a OpenStack based IaaS infrastructure. The results show that the makespan can be reduced by grouping tasks in coarse units of loads.

Using NAS Parallel Benchmarks to evaluate HPC performance in clouds

Cloud computing is a reality nowadays, however there are few studies trying to understand what happens in the actual cloud infrastructures for HPC applications. The focus of this study is the evaluation of NAS Parallel Benchmarks on cloud computing environments. We analyze the execution of applications from NAS Parallel Benchmarks (LU and SP), comparing the execution behavior in different infrastructures: a public cloud, a private cloud and a NUMA multiprocessor system. Our broad goal is to estimate the performance of actual HPC applications on cloud, based on its communication characteristics. We conclude that HPC users should be careful with Virtual Machines with higher virtual CPU count, thanks to Google usage of Hyper-Threading technology and Virtual Machine instances scheduling.

Concurrent Hash Tables for Haskell

This paper presents seven hash table Haskell implementations, ranging from low-level synchronization mechanisms to high-level ones such as transactional memories. The result of the comparison between the algorithms showed that the implementation using the STM Haskell transactional memory library and fine-grain synchronization presented the best performance and good scalability.

Utilization of data structure of low contention in execution core of Anahy-3

This article analyze the use of low contention strategies in the implementation of the Anahy execution environment, specifically at its core scheduling. These strategies aims for overhead reduction when using the mutex to access list data with multiple threads. The results show that the optmized implementations have better performance if compared with STL. This article also compares various multithread execution tools, such as Cilk, TBB and OpenMP. In one of the cases, the result was 190% better. Therefore, Anahy can be an alternative to other environments because of its performance and also for allowing the programmer code with more ease.

Aproximating static list schedules in dynamic multithreaded applications

List scheduling algorithms are known to be efficient when the application to be executed can be described statically as a Directed Acyclic Graph (DAG) of tasks. Regardless of knowing the entire DAG beforehand, obtaining an optimal schedule in a parallel machine is a NP-hard problem. Moreover, many programming tools propose the use of scheduling techniques based on list strategies. This paper presents an analysis of scheduling algorithms for multithread programs in a dynamic scenario where threads are created and destroyed during execution. We introduce an algorithm to convert DAGs, describing applications as tasks, into Directed Cyclic Graphs (DCGs) describing the same application designed in a multithread programming interface. Our algorithm covers case studies described in previous works, successfully mapping from the abstract level of graphs to the application environment. These mappings preserve the guarantees offered by the abstract model, providing efficient scheduling of dynamic programs that follow the intended multithread model. We conclude the paper presenting some performance results we obtained by list schedulers in dynamic multithreaded environments. We also compare these results with the best scheduling we could obtain with similar static task schedulers.

Towards a Power-Aware Application Level Scheduler for a Multithreaded Runtime Environment

At the same time that the modern society becomes more dependent on computing power, people become more concerned about the enviroment and, in consequence, about energy consumption. In the high performance computing field, most works only take into account performance aspects such as throughputs to measure schedulers. In this paper, we introduce and evaluate an energy-aware list scheduler that uses heuristics based on the critical path to determine processor affinity and the clock rate of each core. We have observed that it is possible to implement an execution supportable to offer acceptable performance at same time that provides a strategy to save energy. Two case studies discussed in the paper support this conclusion.

Evaluating Overhead and Contention in Concurrent Accesses to a Graph

The current spread of multicore processors reinforces the need for strategies to implement mutithreaded programs. Since using synchronization methods to coordinate the access to shared data introduces contention, finding new strategies to implement concurrent data structures can lead to performance gains. This paper introduces a case study in which a graph data structure is implemented using low contention strategies: one based on low level atomic operations, one based on mutexes and another using transactional memory. Results show that the first presents better performance, the second the worst performance and the later a higher level of abstraction for programmers with a similar performance to the first.