Hervé Paulino

Algorithmic skeleton framework for the orchestration of GPU computations

The Graphics Processing Unit (GPU) is gaining popularity as a co-processor to the Central Processing Unit (CPU). However, harnessing its capabilities is a non-trivial exercise that requires good knowledge of parallel programming, more so when the complexity of these applications is increasingly rising. Languages such as StreamIt [1] and Lime [2] have addressed the offloading of composed computations to GPUs. However, to the best of our knowledge, no support exists at library level. To this extent, we propose Marrow, an algorithmic skeleton framework for the orchestration of OpenCL computations. Marrow expands the set of skeletons currently available for GPU computing, and enables their combination, through nesting, into complex structures. Moreover, it introduces optimizations that overlap communication and computation, thus conjoining programming simplicity with performance gains in many application scenarios. We evaluated the framework from a performance perspective, comparing it against hand-tuned OpenCL programs. The results are favourable, indicating that Marrows skeletons are both flexible and efficient in the context of GPU computing.

Open virtualization framework for testing ground systems

The recent developments in virtualization change completely the panorama of the Hardware/OS deployment. New bottlenecks arise in the deployment of application stacks, where IT industry will spend most of the time to assure automation. VIRTU tool aims at managing, configuring and testing distributed ground applications of space systems on a virtualized environment, based on open tools and cross virtualization support. This tool is a spin-off of previous activities performed by the European Space Operations Center (ESOC) and thus it covers the original needs from the ground data systems infrastructure division of the European Space Agency. VIRTU is a testing oriented solution. Its ability to group several virtual machines in an assembly provides the means to easily deploy a full testing infrastructure, including the client/server relationships. The possibility of making on-demand request of the testing infrastructure will provide some infrastructure optimizations, specially having in mind that ESA maintains Ground Control software of various missions, and each mission cam potentially have a different set of System baselines and last up to 15 years. The matrix array of supported system combinations is therefore enormous and any improvement on the process provides substantial benefits to ESA, by reducing the effort and schedule of each maintenance activity. The ESOCs case study focuses on the development and validation activities of infrastructure or mission Ground Systems solutions. The Ground Systems solutions are typically composed of distributed systems that could take advantage of virtualized environments for testing purposes. Virtualization is used as way to optimize maintenance for tasks such as testing new releases and patches, test different systems configurations and replicate tests. The main benefits identified are related to deployment test environment and the possibility to have on-demand infrastructure.

Session-Based Compilation Framework for Multicore Programming

This paper outlines a general picture of our ongoing work under EU Mobius and Sensoria projects on a type-based compilation and execution framework for a class of multicore CPUs. Our focus is to harness the power of concurrency and asynchrony in one of the major forms of multicore CPUs based on distributed, non-coherent memory, through the use of type-directed compilation. The key idea is to regard explicit asynchronous data transfer among local caches as typed communication among processes. By typing imperative processes with a variant of session types, we obtain both type-safe and efficient compilation into processes distributed over multiple cores with local memories.

SmART: An Application Reconfiguration Framework

SmART (Smart Application Reconfiguration Tool) is a framework for the automatic configuration of systems and applications. The tool implements an application configuration workflow that resorts to the similarities between configuration files (i.e., patterns such as parameters, comments and blocks) to allow a syntax independent manipulation and transformation of system and application configuration files.Without compromising its generality, SmART targets virtualized IT infrastructures, configuring virtual appliances and its applications. SmART reduces the time required to (re)configure a set of applications by automating time-consuming steps of the process, independently of the nature of the application to be configured. Industrial experimentation and utilization of SmART show that the framework is able to correctly transform a large amount of configuration files into a generic syntax and back to their original syntax. They also show that the elapsed time in that process is adequate to what would be expected of an interactive tool. SmART is currently being integrated into the VIRTU bundle, whose trial version is available for download from the project’s web page.

A Multi-threaded Asynchronous Language

We describe a reference implementation of a multi-threaded run-time system for a core programming language based on a process calculus. The core language features processes running in parallel and communicating through asynchronous messages as the fundamental abstractions. The programming style is fully declarative, focusing on the interaction patterns between processes. The parallelism, implicit in the syntax of the programs, is effectively extracted by the language compiler and explored by the run-time system.

On the support of task-parallel algorithmic skeletons for multi-GPU computing

An emerging trend in the field of Graphics Processing Unit (GPU) computing is the harnessing of multiple devices to cope with scalability and performance requirements. However, multi-GPU execution adds new challenges to the already complex world of General Purpose computing on GPUs (GPGPU), such as the efficient problem decomposition, and dealing with device heterogeneity. To this extent, we propose the use of the Marrow algorithmic skeleton framework (ASkF) to abstract most of the details intrinsic to the programming of such platforms. To the best of our knowledge, Marrow is the first ASkF to support skeleton nesting on single and (now) multiple GPU systems. In this paper we present how it can transparently distribute the execution of skeleton compositions among a set of, possibly, heterogeneous devices. An experimental evaluation assesses the proposals effectiveness, from a scalability and performance perspective, with good results.

Towards an Adaptable Middleware for Parallel Computing in Heterogeneous Environments

The adoption of the multi-core processor design has spawned a wide variety of CPU configurations, namely in the number and nature of the hosted cores. The cluster organization of such CPUs is particularly sensitive to this issue, since applications must be aware of such heterogeneity in order to fully exploit the potential of the underlying hardware. The existing frameworks for cluster computing do not fully address this issue, relying on the programmer to handle many of the concerns associated to the aforesaid heterogeneity, burdening him with non-functional details. To this extent, we propose an adaptable middleware for Java High-Performance Computing in heterogeneous clusters. Adaptability is obtained by trusting the runtime system with the management of thread and data placement, and by equipping it with a layer able to adjust its implementation to the particularities of the underlying software and hardware stacks. In this paper we address both the middlewares programming model and runtime system, as well as some initial performance results that attest the validity of the approach.

A service-oriented language for programming mobile agents

In this paper we present MOB, a service-oriented scripting language for programming mobile agents in distributed systems. The main feature of the language is the integration of the service-oriented and the mobile agent paradigms. MOB is encoded onto a process calculus with a well studied semantics which provides us with a tool to prove the soundness of the language relative to the underlying calculus.

A mobile agent service-oriented scripting language encoded on a process calculus

We present a service-oriented scripting language for programming mobile agents in distributed systems. The main novelty of the language we call Mob, is the integration of the service-oriented and mobile agent paradigms. Mob is also encoded onto a process calculus with a well studied semantics. The encoding provides a specification for the front-end of the language compiler and allows us to use, for the back-end and for the run-time system, a compiler and a virtual machine previously developed for the process calculus.

Dynamic Interaction Models for Web Enabled Wireless Sensor Networks

Wireless Sensor Networks (WSNs) are a fundamental technology for science in many domains, and their inclusion in Web environments, e.g. through Web services, allows for their open/standard access and integration. Although such Web enabled WSNs simplify data access, network parametrisation and aggregation, the available interaction models and run-time adaptation mechanisms are still scarce. Nevertheless, applications increasingly demand richer and more flexible interface accesses, for instance, the interaction model dynamic adaptation according to contextual information. To this extent, this paper discusses the relevance of the session and pattern abstractions on the design of a middleware prototype providing richer interaction models, as well as a few context-based dynamic adaptation mechanisms for Web enabled WSNs.