José M. Piquer

Garbage collecting the world

Distributed symbolic computations involve the existence of remote references allowing an object, local to a processor, to designate another object located on another processor. To reclaim inaccessible objects is the non trivial task of a distributed Garbage Collector (GC). We present in this paper a new distributed GC algorithm which (i) is fault-tolerant, (ii) is largely independent of how a processor garbage collects its own data space, (iii) does not need centralized control nor global stop-the-world synchronization, (iv) allows for multiple concurrent active GCs, (v) does not require to migrate objects from processor to processor and (vi) eventually reclaims all inaccessible objects including distributed cycles. These results are mainly obtained through the concept of a group of processors (or processes). Processors of a same group cooperate together to a GC inside this group; this GC is conservative with respect to the outside of the group. A processor contributes to the global GC of all groups to which it belongs. Garbage collection on small groups reclaims quickly locally distributed garbage clusters, while garbage collection on large groups ultimately reclaims widely distributed garbage clusters, albeit more slowly. Groups can be reorganized dynamically, in particular to tolerate failures of some member processors. These properties make the algorithm usable on very large and evolving networks of processors. Other than distributed symbolic computations, possible applications include for example distributed file or database systems.

Skandium: Multi-core Programming with Algorithmic Skeletons

This paper argues that algorithmic skeletons are a suitable programming model for multi-core architectures. The high-level abstractions offered by algorithmic skeletons provide a simple way for non-parallel programmers to address parallel programming. Previous algorithmic skeleton frameworks and libraries have addressed distributed computing environments such as Clusters and Grids. This paper proposes a parallel skeleton library, Skandium; and concludes, after an experimental evaluation, that algorithmic skeletons are an effective methodology to program multi-core architectures.

Altering Java Semantics via Bytecode Manipulation

Altering the semantics of programs has become of major interest. This is due to the necessity of adapting existing software, for instance to achieve interoperability between off-the-shelf components. A system allowing such alterations should operate at the bytecode level in order to preserve portability and to be useful for pieces of software whose source code is not available. Furthermore, working at the bytecode level should be done while keeping high-level abstractions so that it can be useful to a wide audience. In this paper, we present Jinline, a tool that operates at load time through bytecode manipulation. Jinline makes it possible to inline a method body before, after, or instead of occurrences of language mechanisms within a method. It provides appropriate high-level abstractions for fine-grained alterations while offering a good expressive power and a great ease of use.

Indirect distributed garbage collection: handling object migration

In new distributed systems, object mobility is usually allowed and is sometimes used by the underlying object manager system to benefit from object access locality. On the other hand, in-transit references to objects can exist at any moment in asynchronous distributed systems. In the presence of object mobility and in-transit references, many garbage collector (GC) algorithms fail to operate correctly. Others need to use the systems object finder to find the objects while performing their work. As a general principle, a GC should never interfere with object manager polices (such as forcing migration or fixing an object to a given processor). However, if the GC uses the object finder, it will change the access pattern of the system, and eventually it could foul the global allocation policy. In this article we propose a new GC family, Indirect Garbage Collectors, allowing to separate the problems of object management (placement, replication, and retrieval) from garbage collection. This property allows our algorithms to be implemented on top of almost any existent distributed object system, without having to use the object finder.

Managing references upon object migration: applying separation of concerns

Java mobile object systems generally rely on Java RMI (Remote Method Invocation) to transmit objects between remote sites. As a consequence, the semantics of parameter passing and value returning is restricted to the choices made by, the designers of RMI. Nevertheless, some applications require more adaptability in this regard. Resources (i.e., passive objects) may need to be transferred using a particular strategy depending not only on their type (like RMI statically permits), but also possibly on application-specific criteria, such as instance-based (e.g, the expected size of an instance) or environment-based (e.g., the state of the net-work). Indeed, the strategy adopted to transmit an object can be seen as a nonfunctional aspect, and therefore should possibly be specified separately from the application object code, and its use should be transparent. We present how a suitable reflective extension of Java can easily be applied to elegantly solve this issue, achieving a clean separation of concerns. We illustrate our approach by showing the implementation of a metaobject for the rebinding policy, and a concrete example of use. We also briefly explain our solution for the remote reference policy.

Balancing active objects on a peer to peer infrastructure

We present a contribution on dynamic load balancing for distributed and parallel object-oriented applications. We specially target on peer to peer systems and its capability to distribute parallel computation, which transfer large amount of data (called intensive-communicated applications) among large number of processors. We explain the relation between active objects and processors load. Using this relation, and defining an order relation among processors, we describe our active object balance algorithm as a dynamic load balance algorithm, focusing on minimizing the time when active objects are waiting for the completion of remote calls. We benchmark a Jacobi parallel application with several load balancing algorithms. Finally, we study results from these experimentation in order to show that a peer to peer load balancing obtains the best performance in terms of migration decisions and scalability.

Indirect Mark and Sweep: A Distributed GC

Distributed Garbage Collection has been studied over the last several years leading to many different implementations, mainly based on local garbage collection algorithms extended to handle concurrency and message ordering. However, the algorithms are usually presented tightly coupled with underlying object managing systems. In the presence of object mobility and in-transit references to objects, many garbage collector (GC) algorithms fail to operate correctly.

How AdkintunMobile measured the world

On this article we present the Adkintun Mobile Project: using passive monitors to measure the Quality of Service of Chilean Mobile Internet Providers, based on the metrics of antenna coverage and Internet connectivity. We present the main ideas, design decisions, development issues and setbacks of the project. Our contribution is to present to the readers the whole process of a project like this, which is based in volunteering and political decisions.

Load Information Sharing Policies In Communication-Intensive Parallel Applications

One usage of Grid infrastructures is to perform parallel computing of scientific applications, most of the time related to hard sciences (physics, chemistry, biology). To exploit parallelism most of these applications are intensive communicated in data and synchronisation messages. On this context, grid systems have to take in account to not interfering with the normal execution of applications. Starting from this idea, in this article we present a study of information sharing policies used by load-balancing algorithms developed for the middleware ProActive, analyzing the performance scalability of: response time (time of reaction against instabilities) and bandwidth, from a communication-intensive application context. We divided the policies into: Centralized or Distributed oriented; and Eager or Lazy load information sharing. Our experimental results show that Eager Distributed oriented policies have better performance (response time and bandwidth usage).

Coupling contracts for deployment on alien grids

We propose coupling based on contracts as a mechanism to address the problem of exchanging information between parties that require information to work together. Specifically, we show how our approach can be used to couple the deployment of an application with a Grid infrastructure deployment descriptor using ProActive[11, 2]. To achieve this, we identify the properties related with information exchange between parties, and we group the properties of interest into typed clauses. We then propose that interfaces can be built using shared typed clauses. If the interfaces between parties are compatible, the coupling of the interfaces can yield a coupling contract. The clauses belonging to the contract represent what information can be shared between the parties, and the type of the clause specifies how this information will be shared. Finally, we show how the deployment of applications on the Grid can benefit from the proposed approach. Unfamiliar applications can couple with deployment descriptors to deploy on alien Grids, without modifying or inspecting neither of them.