Mario Leyton

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.

Fine tuning algorithmic skeletons

Algorithmic skeletons correspond to a high-level programming model that takes advantage of nestable programming patterns to hide the complexity of parallel/distributed applications. Programmers have to: define the nested skeleton structure, and provide the muscle (sequential) portions of code which are specific to a problem. An inadequate structure definition, or inefficient muscle code can lead to performance degradation of the application. Related research has focused on the problem of performing optimization to the skeleton structure. Nevertheless, to our knowledge, no focus has been done on how to aide the programmer to write performance efficient muscle code. We present the Calcium skeleton framework as the environment in which to perform fine tuning of algorithmic skeletons. Calcium provides structured parallelism in Java using ProActive. ProAcitve is a grid middleware implementing the active object programming model, and providing a deployment framework. Finally, using a skeleton solution of the NQueens counting problems in Calcium, we validate the fine tuning approach on a grid environment.

Identification and subcellular localization of two isoenzymes of apyrase from Solanum tuberosum

Abstract Two forms of ATP-diphosphohydrolase were identified in Solanum tuberosum tuber var. Ultimus. Their hydrolytic activity ratios (ATPase/ADPase) were over 10 for form A and 1 for form B. In the potato tuber homogenate the hydrolytic activity ratio is 3.0, as a result of contributions of the two forms of apyrase. These two apyrases (A and B) were partially separated and the possibility that they are produced as an artifact by partial proteolysis or subunit aggregation was excluded. The subcellular localization of the Ultimus isoapyrases was studied by differential centrifugation. These enzymes are localized in distinct compartments. The high ratio enzyme (A) lies mainly in the soluble fraction, while the low ratio apyrase (B) is principally bound to membranes. The two isoapyrases differ greatly in their kinetic properties and p I , but only slightly in M r . Both enzymes immunocross-react with antiapyrase Desiree, which is important for isoenzyme detection by the immunowestern blot. This is the first example of two isoenzymes of apyrase in the same variety of S. tuberosum .

Type Safe Algorithmic Skeletons

This paper addresses the issue of type safe algorithmic skeletons. From a theoretical perspective we contribute by: formally specifying a type system for algorithmic skeletons, and proving that the type system guarantees type safety. From an implementation point of view, we show how it is possible to enforce the type system on an Java based algorithmic skeleton library. The enforcement takes place at the composition of the skeleton program, by typing each skeleton with respect to its construction parameters: sequential functions, and other skeletons. As a result, hierarchical skeleton nesting can be performed safely, since type errors can be detected by the skeleton type system.

Purification and characterization of two isoapyrases from Solanum tuberosum var. ultimus

Abstract Two isoenzymes of ATP-diphosphohydrolase (apyrase) were extracted and purified from S. tuberosum var. Ultimus. Their hydrolytic activity ratios (ATPase/ADPase) were 1.0 (apyrase B) and ca 15.0 (apyrase A). They were characterized and compared with apyrases of other varieties of S. tuberosum . Ultimus apyrases, like the other apyrases, did not hydrolyse esteric bonds but only pyrophosphate bonds of organic and inorganic compounds. The optimum pH of all the studied hydrolytic activities of the Ultimus apyrases A and B was 6, except for the ADPase of enzyme A which was 8. Both enzymes require bivalent metal ions for catalytic activity. The activation order for both Ultimus enzymes was: Ca 2+ >Mn 2+ > Mg 2+ >Co 2+ >Zn 2+ . Chemical modification of tryptophan, tyrosine, arginine and carboxylic residues decreased all enzymic activities of both apyrases. The modification of histidine residues reduced the ATPase and ADPase activities of the low ratio apyrase and the ATPase of the high ratio enzyme but did not affect its ADPase activity. Neither of the Ultimus apyrases showed the participation of -SH groups in the active site. The pI values obtained were: 5.45 for apyrase B and 6.56 for apyrase A. The absorption and the fluorescence spectra of the Ultimus isoenzymes were coincident. The amino acid composition of both isoenzymes is very similar, the number of histidines being the most remarkable difference. The amino acid composition of both isoenzymes does not explain the difference of one pH unit in the isoelectric point between the Ultimus enzymes A and B.

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.

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.

Exceptions for algorithmic skeletons

Algorithmic skeletons offer high-level abstractions for parallel programming based on recurrent parallelism patterns. Patterns can be combined and nested into more complex parallelism behaviors. Programmers fill the skeleton patterns with the functional (business) code, which transforms the generic skeleton into a specific application. However, when the functional code generates exceptions, programmers are exposed to implementation details of the skeleton library, breaking the high-level abstraction principle. Furthermore, related parallel activities must be stopped as the exception is raised. This paper describes how to handle exceptions in algorithmic skeletons without breaking the highlevel abstractions of the programming model. We describe both the behavior of the framework in a formal way, and its implementation in Java: the Skandium Library.

Grid file transfer during deployment, execution, and retrieval

We propose a file transfer approach for the Grid We have identified that file transfer in the Grid can take place at three different stages: deployment, user application execution, and retrieval (post-execution) Each stage has different environmental requirements, and therefore we apply different techniques Our contribution comes from: (i) integrating heterogeneous Grid resource acquisition protocols and file transfer protocols including deployment and retrieval, and (ii) providing an asynchronous file transfer mechanism based on active objects, wait-by-necessity, and automatic continuation. We validate and benchmark the proposed file transfer model using ProActive, a Grid programming middleware ProActive provides, among others, a Grid infrastructure abstraction using deployment descriptors, and an active object model using transparent futures.