Alexandre C. Sena

Distributed and dynamic self-scheduling of parallel MPI Grid applications

The execution of distributed applications on the Grid is already a reality. However, as both the number of applications grow and Grids increase in scale, the efficient utilization of the available but shared heterogeneous resources will become increasingly essential to the Grids successful maturity. Furthermore, it is unclear whether existing Grid management systems are capable of meeting this challenge. The EasyGrid middleware is a hierarchically distributed application management system (AMS) that is embedded into MPI applications to autonomously orchestrate their execution efficiently in computational Grids. The overhead of employing a distinct AMS to make each application system aware brings at least two benefits. First, the adopted policies can be tailored to the specific needs of each application, leading to improved performance. Second, distributing the management effort among executing applications makes Grid management more scalable. This article focuses on scheduling policies of an AMS for a particular class of application, describing a low intrusion implementation of a hybrid scheduling strategy designed to elicit good performance even in dynamic environments such as Grids. Using application‐specific scheduling policies, near‐optimal runtimes highlight the advantages of self‐scheduling when executing one or more system aware applications on a Grid. Copyright

On the Advantages of an Alternative MPI Execution Model for Grids

The MPI message passing library is used extensively in the scientific community as a tool for parallel programming. Even though improvements have been made to existing implementations to support execution on computational grids, MPI was initially designed to deal with homogeneous, fault- free, static environments such as computing clusters. The typical programming approach is to execute a single MPI process on each resource. However, this may not be appropriate for heterogeneous, non-dedicated and dynamic environments such as grids. This paper aims to show that programmers can implement parallel MPI solutions to their problems in an architectural independent style and obtain good performance on a grid by transferring responsibility to an application management system (AMS). A comparison of program implementations under a traditional MPI execution model and a fine-grain model highlight the advantages of using the latter.

EasyGrid Enabling of Iterative Tightly-Coupled Parallel MPI Applications

This paper addresses the challenge of how to permit tightly coupled parallel applications, optimised for uniform, stable, static environments, execute equally efficiently in environments which exhibit the complete opposite characteristics. Using the N-body problem as a case study, both the traditional and proposed grid enabled MPI implementations of the popular ring algorithm are analysed. Results with respect to performance show the latter approach to be competitive on a cluster and significantly more effective in heterogeneous and dynamic environments.

Task Scheduling in Sucuri Dataflow Library

Sucuri is a minimalistic Python library that provides dataflow programming through a reasonably simple syntax. It allows transparent execution on computer clusters and natural exploitation of parallelism. In Sucuri, programmers instantiate a dataflow graph, where each node is assigned to a function and edges represent data dependencies between nodes. The original implementation of Sucuri adopts a centralized scheduler, which incurs high communication overheads, specially in clusters with a large number of machines. In this paper we modify Sucuri so that each machine in a cluster will have its own scheduler. Before execution, the dataflow graph is partitioned, so that nodes can be distributed among the machines of the cluster. In runtime, idle workers will grab tasks from a ready queue in their local scheduler. Experimental results confirm that the solution can reduce communication overheads, improving performance in larger clusters.

Autonomic Malleability in Iterative MPI Applications

During their execution, a significant number of applications often sub utilize the capacity of the resources to which they are allocated or require more. Furthermore, with the current scale up trend in server design, effective utilization can only be achieved by applications sharing such resources. Cluster management systems already support static resource partitioning at job submission time and given that application utilization more than often varies during the execution, it will become increasingly more important to permit applications to harness all available spare capacity. This paper investigates the feasibility of malleable evolving versions of applications to improve performance and system efficiency. Extending a previous classification, we show that improvements can be achieved for a real astrophysics application.

An Approach to Optimise the Execution of RTM Algorithm in Multicore Machines

The new oil fields discovered in the Gulf of Mexico and in Brazils southeast coast are located in deep water, which imposes new challenges for sub salt seismic imaging. To produce sufficient accurate imaging of such fields, the compute intensive RTM method is the currently favoured approach, despite its high computational cost. This work evaluates the RTM code in multicore machines and proposes a new version that is more than 2.4 faster than the original. Besides, how the memory hierarchy is utilised has a crucial impact on the performance of the code. This article also presents an innovative approach to calculate efficient block values for a better memory utilisation on multicore archictetures.

Autonomic application management for large scale MPI programs

Computational grids aim to aggregate significant numbers of resources to provide sufficient, but low cost, computational power to various applications. Writing applications capable of executing efficiently in grids, is however extremely difficult. Their geographically distributed resources are typically heterogeneous, non-dedicated, and offer no performance or availability guarantees. This makes the collective management of resources and application both complex and arduous. This work investigates an alternative approach (based on system-awareness) to solve the problem of developing and managing the execution of grid applications efficiently. Results show that these system-aware applications are indeed faster than their conventional implementations and easily grid enabled.

A Communication Protocol for Fog Computing Based on Network Coding Applied to Wireless Sensors

A communication protocol for fog computing should be efficient, lightweight and customizable. In this work we focus in a communication protocol for fog nodes composed of wireless sensors, which are spatially distributed autonomous sensors monitoring physical or environmental conditions. Problems with data congestion and limited physical resources are common in these networks. For the optimization of data flow, it is important to apply techniques that reduce the transmitted data. We use the network coding technique to demonstrate through experiments the degree of efficiency of data transmission optimization protocols. The experiments were performed through a wireless sensors programming framework composed of TinyOS operating system, NesC programming language and TOSSIM simulator. In addition, we use the Python programming language to simulate the wireless sensor network topology. The results obtained demonstrate a better performance (50% up to 60%) when the network coding technique is applied to the data communication protocol.

Graph Templates for Dataflow Programming

Current works on parallel programming models are trending towards the dataflow paradigm, which naturally exploits parallelism in programs. The Sucuri Python Library provides basic features for creation and execution of dataflow graphs in parallel environments. However, there is still a gap between dataflow programming and traditional parallel programming. In this paper we aim at narrowing that gap by introducing a set of templates for Sucuri that represent some of the most important parallel programming patterns. Through these templates programmers can implement applications that use patterns such as fork/join, pipeline and wave front just by instantiating and connecting sub-graph objects. Evaluation showed that the use of templates makes programming easier, while allowing a significant reduction in lines of code, compared to manually creating the dataflow graph.

A Dataflow Implementation of Region Growing Method for Cracks Segmentation

Region growing is an image segmentation algorithm extremely useful for continuous regions extraction. It defines an initial set of seeds, according to a specific criteria, and iteratively aggregates similar neighbor pixels. The algorithm converges when no pixel aggregation is performed in a certain iteration. Within this research project, region growing is employed for the segmentation of cracks in images of ore particles acquired by scanning electron microscopy (SEM). The goal is to help scientists evaluate the efficiency of cracking methods that would improve metal exposure for extraction through heap leaching and bioleaching. However, this is a computational intensive application that could take hours to analyze even a small set of images, if executed sequentially. This paper presents and evaluates a dataflow parallel version of the region growing method for cracks segmentation. The solution employs the Sucuri dataflow library for Python to orchestrate the execution in a computer cluster. Since the application processes images of different sizes and complexity, Sucuri played an important role in balancing load between machines in a transparent way. Experimental results show speedups of up to 26.85 in a small cluster with 40 processing cores and 23.75 in a 36-cores machine.