Cristina D. Ururahy

Dynamic support for distributed auto-adaptive applications

This work presents an infrastructure that simplifies the development of distributed applications that can adapt automatically to nonfunctional properties of their components and of their execution environment. This infrastructure, based on the programming language Lua and on CORBA, allows applications to select dynamically the components that best suit their requirements, to verify whether the system is satisfying these requirements, and to react, when appropriate, to variations in the nonfunctional properties of the services in use. We use CORBAs trading service to support dynamic component selection. An extensible monitoring facility supports monitoring of dynamically defined requirements. We use the Lua language to specify adaptation strategies, and a smart proxy mechanism to apply these strategies.

ALua: flexibility for parallel programming

In this paper we present ALua, an event-driven communication mechanism for developing distributed parallel applications, based on the interpreted language Lua. We propose a dual programming model for parallel applications, where ALua acts as a gluing element, allowing precompiled program parts to run on different machines. We show, through examples, how three types of applications can benefit from the flexibility that derives from this model. We then present a study of ALuas performance, by comparing execution times of two parallel applications written in ALua with their counterparts written in PVM.

CSBase: A Framework for Building Customized Grid Environments

This paper describes CSBase, a framework that allows the development of customized grid environments. CSBase provides end-users with a simplified access to grid resources and applications. Although all CSBase instances share some common services, such as user and algorithm management services, each instance has its own Web interface and specialized applications and services. CSBase is based on the experience gathered from projects developed by our research group in collaboration with industrial partners. This paper also describes some of these projects

Programming and coordinating Grid environments and applications

The heterogeneous and dynamic nature of Grid environments place new demands on models and paradigms for parallel programming. In this work we discuss how ALua, a programming system based on a dual programming language model, can help the programmer to develop applications for this environment, monitoring the state of resources and controlling the application so that it adapts to changes in this state. Copyright

The Use of Interpreted Languages for Implementing Parallel Algorithms on Distributed Systems

Parallel programs have traditionally been implemented on distributed systems using conventional programming languages, such as Fortran or C, plus a library with support for communication, such as, for instance, PVM [11]. Also, some effort has been put into developing parallel programming languages [13]. Usually, the different development platforms are compared as to application execution time or parallel efficiency. However, as pointed out in [4], when measuring the performance of a parallel application or programming tool, different metrics may need to be taken into consideration. The ease of construction of an application and the time a programmer spends to implement it may in some cases be more important than the final execution time. Working under this assumption, this work argues that the use of interpreted languages as a basis for parallel programming tools should be further investigated. As support for our argument, we show an example of use of an interpreted language in a classical application in parallel distributed programming, namely, that of detecting program termination. Two different algorithms for termination detection are implemented in Lua, an extension language developed at PUC-Rio [5].

An event-driven system for distributed multimedia applications

We propose an architecture for distributed multimedia applications based on an event-driven programming model. To avoid the synchronization problems inherent to multi-threaded programming, the proposed architecture is based on a single-threaded structure. Instead of multi-threading, we opted for the event-oriented approach allied to multiple communication channels with user-defined handling procedures to allow the application to deal concurrently with control and data streams. We discuss this programming model, present the system we have implemented based on this model, and describe the experience we have had with this system.