On the Move to Meaningful Internet Systems 2006: CoopIS, DOA, GADA, and ODBASE

This volume contains the papers presented at GADA 2006, the International Conference on Grid Computing, High-Performance and Distributed Applications. The purpose of the GADA series of conferences, held in the framework of the OnTheMove Federated Conferences (OTM) federated conferences, is to bring together researchers, developers, professionals and students in order to advance research and development in the, areas of grid computing and distributed systems and applications. This years conference was in Montpellier, France, from November 2 to November 3.

As is becoming commonly known, there is an explosion happening in the amount of scientific data that is publicly available. One challenge is how to make productive use of this data. This talk will discuss some parallel and distributed computing projects, centered around virtual astronomy, but also including other scientific data-oriented realms. It will look at some specific projects from the past, including Montage, Grist, OurOcean, and SCOOP, and will discuss the distributed computing, Grid, and Web-service technologies that have successfully been used in these projects.

Since many human activities depend on the creation, use and transmission of symbolic information advances in our ability to produce and use such information (semi)automatically can be expected to have great impact on society and economic development. For this reason, this objective has been proposed as one of the main activities under Framework programme 7 (FP7), the next cycle of EU research and development activities and funding to run through 2007-2013. This paper gives a broad overview of the place of content and knowledge in FP7 and discusses several specific lines of research that have been identified as particularly important and promising.

The latest Globus Toolkit 4 (GT4) version, fully OGSA compliant and almost completely based on Grid Services, is expected to become the reference version of the Globus Toolkit. Therefore, the necessity to migrate from previous versions, especially the widespread GT2, to GT4 is becoming a relevant issue for many Grid systems.

We present a migration experience from GT2 to GT4 of a simple tool for resource discovery and selection, and execution of parallel applications in a computational Grid environment.

The proposed tool provides a simple and intuitive user interface, a structured view of Grid resources, a simple mechanism for resource selection, and support for application staging and execution.

We discuss some relevant differences between GT2 and GT4, particularly for the Monitoring and Discovering subsystem. GT4 turns out to be more powerful and flexible.

Just because we address the implementation of basic functionalities, the proposed discussion may be of general interest.

Metascheduling is a key functionality of the grid middleware in order to achieve a reasonable degree of performance and reliability, given the changing conditions of the computing environment. In this contribution a comparative analysis between two major grid scheduling philosophies is shown: a semi-centralized approach, represented by the EGEE Workload Management System, and a fully distributed approach, represented by the Grid

W

ay Metascheduler. This comparative is both theoretical, through a functionality checklist, and experimental, through the execution of a fusion plasma application on the EGEE infrastructure.

Both in High Performance Computing and in Grid computing dynamic load balancing is becoming one of the most important features. In this paper, we present a novel load balancing model based on Lattice Boltzmann Cellular Automata. Using numerical simulations our model is compared to diffusion algorithms adopted on HPC load balancing and to agent-based balancing strategies on Grid systems. We show how the proposed model generally gives better performances for both the considered scenarios.

The development of complex applications that use the Peer-to-Peer computing model is restrained by security and trust management concerns, despite evident performance benefits. An example of such an application of P2P computing is P2P Massive Multi-user Online Games, where cheating by players is simple without centralized control or specialized trust management mechanisms. The article presents new techniques for trust enforcement that use cryptographic methods and are adapted to the dynamic membership and resources of P2P systems. The proposed approach to trust management differs significantly from previous work in the area that mainly used reputation. The paper describes a comprehensive trust management infrastructure fore P2P MMO games that enables to recognize and exclude cheating players while keeping the performance overhead as low as possible. While the architecture requires trusted centralized components (superpeers), their role in trust management is limited to a minimum and the performance gains of using the P2P computing model are preserved.

TEDDY applications form a distributed package designed for data acquisition and evaluation of inspections carried out in nuclear power plants. These inspections typically involve a number of acquisition equipments exploring the state of different parts of the plant in order to detect any kind of failure. Currently, these applications follow a typical client-server model, where every client –up to one hundred– accesses a central server containing all the information about the inspection itself; furthermore, it centralizes all the coordination and synchronization mechanisms of the work. The client applications act as producer/consumer from server data, so that a failure in the server should halt all the activity in the inspection. In this paper, we propose a peer to peer model where all the nodes share the information and discuss the pros and cons of the new system.

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.

Most of the grid projects are characterized by accessing huge volumes of data. For supporting this feature, different data services have arisen in the “grid” world. One of the most successful initiatives in that field is GridFTP, a high-performance transfer protocol, based on FTP but optimized for wide area networks. Although GridFTP provides reasonably good performance, GridFTP servers keep constituting a bottleneck for data-intensive applications.

One of the most important modules of a GridFTP server is the Data Storage Interface (DSI), which specifies how to read and write to the storage system, allowing the server to transform the data. With the aim of improving the performance of the GridFTP server, we have designed a new DSI, based on MAPFS, a parallel file system. This paper describes this new DSI and its evaluation, showing the advantages of dealing data through this optimized GridFTP server.

We present in this article a parallelization of a discrete radiosity method, based on scene division and achieved on a cluster of workstations. This method is based on discretization of surfaces into voxels and not into patches like most of the radiosity methods do. Voxels are stocked into visibility lists representing the space partition into discrete lines and allowing mutually visible neighbour voxels to exchange their radiosities. The parallelization distributes the scene among the processors by dividing it into parts. Exchanges of radiosity values are accomplished between neighbourhood voxels belonging to a same list but located on different processors. This parallelization improved time and distributed memory offering thus the capability to deal with large scenes.

The continuing growth of the Internet challenges search engine providers to deliver up-to-date and relevant search results. A critical component is the availability of a rapid, scalable technique for PageRank computation of a large web graph. In this paper, we propose an efficient parallelized version of the PageRank algorithm based on a mixed MPI and multi-threading model. The parallel adaptive PageRank algorithm is implemented and tested on two clusters of SMP hosts. In the algorithm, communications between processes on different hosts are managed by a message passing (MPI) model, while those between threads are handled via a inter-thread mechanism. We construct a synthesized web graph of approximately 62.6 million nodes and 1.37 billion hyperlinks to test the algorithm on two SMP clusters. Preliminary results show that significant speedups are possible; however, large inter-node synchronization operations and issues of shared memory access inhibit efficient CPU utilization. We believe that the proposed approach shows promise for large-scale PageRank applications and improvements in the algorithm can achieve more efficient CPU utilization.

The paper describes a solution to the key problem of ensuring high performance behavior of the Grid, namely the scheduling of activities. It presents a distributed, fault-tolerant, scalable and efficient solution for optimizing task assignment. The scheduler uses a combination of genetic algorithms and lookup services for obtaining a scalable and highly reliable optimization tool. The experiments have been carried out on the MonALISA monitoring environment and its extensions. The results demonstrate very good behavior in comparison with other scheduling approaches.

Evolutionary Algorithms (EA) are well suited for solving optimisation problems, especially NP-complete problems. This paper presents the application of the Evolutionary Algorithm GLEAM (

G

eneral

L

earning and

E

volutionary

A

lgorithm and

M

ethod) in the field of grid computing. Here, grid resources like computing power, software, or storage have to be allocated to jobs that are running in heterogeneous computing environments. The problem is similar to industrial resource scheduling, but has additional characteristics like co-scheduling and high dynamics within the resource pool and the set of requesting jobs. The paper describes the deployment of GLEAM in the global optimising grid resource broker GORBA (

G

lobal

O

ptimising

R

esource

B

roker and

A

llocator) and the first promising results in a grid simulation environment.

Computational Grids provide computing power by sharing resources across administrative domains. This sharing, coupled with the need to execute distrusted task from arbitrary users, introduces security hazards. This study mainly examines the integration of the notion of “trust” into resource management based on Grid economic model to enhance Grid security. Our contributions are two-fold: First, we propose a trust function which based on dynamic trust changing and construct a Grid trust model based on behavior. Second, we present trust-aware time optimization scheduling algorithm within budget constraints and trust-aware cost optimization scheduling algorithm within deadline constraints. The performance of these algorithms excels that of algorithm without considering trust via theory analysis and simulation experiment.

In the Service Oriented Architecture (SOA) complex applications can be described as business processes from independently developed services that can be selected at run time on the basis of the provided Quality of Service (QoS). However, QoS requirements are difficult to satisfy especially for the high variability of Internet application workloads. Autonomic grid architectures, which provide basic mechanisms to dynamically re-configure service center infrastructures, can be be exploited to fullfill varying QoS requirements. We tackle the problem of selection of Web services that assure the optimum mapping between each abstract Web service of a business process and a Web service which implements the abstract description, such that the overall quality of service perceived by the user is maximized. The proposed solution guarantees the fulfillment of global constraints, considers variable quality of service profile of component Web services and the long term process execution. The soundness of the proposed solution is shown trough the results obtained on an industrial application example. Furthermore, preliminary computational experiments show that the identified solution has a gap of few percentage units to the global optimum of the problem.

The paper describes a self-operating integration mechanism for virtual repository’s distributed resources based on object-oriented databases in a grid architecture. The core architecture is based on the SBA theory and its virtual updateable views. Our virtual repository transparently processes heterogeneous data producing conceptually and semantically coherent results. Our integration apparatus is explained by two examples with different types of fragmentations – horizontal and vertical. A transparent integration process exploits a global index mechanism and an independent virtual P2P network for a communication between distributed databases. Researches presented in the paper are based on a prototype integrator which is currently under development.

Grid workflows are very often composed of multilingual applications. Monitoring such multilingual workflows in the Grid requires an instrumentation infrastructure that is capable of dealing with workflow components implemented in different programming languages. Moreover, Grid workflows introduce multiple levels of abstraction and all levels must be taken into account in order to understand the performance behaviour of a workflow. As a result, any instrumentation infrastructure for Grid workflows should assist the user/tool to conduct the monitoring and analysis at multiple levels of abstraction. This paper presents a novel instrumentation infrastructure for Grid services that addresses the above-mentioned issues by supporting the instrumentation of multilingual Grid workflows at multiple levels of abstraction using a unified, highly interoperable interface.

Task scheduling is an essential aspect of parallel process system. Most heuristics for this NP-hard problem assume fully connected homogeneous processors and ignore contention on the communication links. Actually, contention for communication resources has a strong influence on the execution time of a parallel program in arbitrary network topology heterogeneous system. This paper investigates the incorporation of contention awareness into task scheduling. The innovation is the idea of dynamic scheduling edges to links, which we use the earliest communication finish time search algorithm based on shortest-path search algorithm. The other novel idea proposed in this paper is scheduling priority based on recursive rank computation on heterogeneous arbitrary architectures. The comparison study, based on randomly generated graphs, shows that our scheduling algorithm significantly surpass classic and static communication contention awareness algorithm, especially for high data transmission rate parallel application

Globus Toolkit version 4 (GT4) provides a set of new services and tools, completing a first step towards the migration to web services of previous Globus Toolkit versions. It provides components addressing basic issues related to security, resource discovery, data movement and management, etc. However, it still lacks from advanced management frameworks that may be linked to GT4 services and thus providing a system-wide view of these services. This is especially true in the case of security related services. They need to be properly managed all across different organizations collaborating in the grid infrastructure. This paper presents the major achievements when designing and developing a semantic-aware management framework for GT4 security services.

The rapid advancement of technologies such as Grid computing, peer-to-peer networking, Web Services to name a few, offer for companies and organizations an open and decentralized environment for dynamic resource sharing and integration. Globus toolkit emerged as the main resource sharing tool used in the Grid community.

Access control and access rights management become one of the main bottleneck when using Globus because in such an environment there are potentially unbounded number of users and resource providers without a priori established trust relationships. Thus, Grid computational resources could be executed by unknown applications running on behalf of distrusted users and therefore the integrity of those resources must be guaranteed.

To address this problem, the paper proposes an access control system that enhances the Globus toolkit with a number of features: (i) fine-grained behavioral control; (ii) application-level management of user’s credentials for access control; (iii) full-fledged integration with X.509 certificate standard; (iv) access control feedback when users do not have enough permissions.

This paper is a case study on the use of a high-level, aspect-oriented programming technology for the modelling of the communication and interaction scheme that affects the set of components of a parallel scientific application. Such an application uses domain decomposition methods and static grid adaptation techniques in order to obtain the numerical solution of a reaction-diffusion problem modelled as a system of two time-dependent, non-linearly coupled partial differential equations. Besides achieving the usual advantages in terms of modularity and reusability, we aim to improve the efficiency by means of dynamic changes of aspects at runtime. The application design considers two types of components as first-order entities: Scientific Components (SCs) for the computational tasks and Communication Aspect Components (CACs) for dynamic management of the communication among SCs. The experiments show the suitability of the proposal as well as the performance benefits obtained by readjusting the communication aspect.

This paper presents an application programming interface called MGS which supports service development in the Mobile Grid Service middleware framework. Mobile Grid Services, the extension of the original static Grid services, are characterized by the ability of moving from nodes to nodes during execution. By combining an existing mobile agent system (JADE) and a generic grid system toolkit (Globus), the Mobile Grid Services framework is constructed. The API consisting of the AgentManager class, Task Agent template and configurable Monitor Agent is used to provide both an easy and flexible environment for Mobile Grid Services development.

Data grid is developed to facilitate sharing data and resources located in different parts of the world. The major barrier to support fast data access in a data grid is the high latency of wide area networks and the Internet. Data replication is adopted to improve data access performance. When different sites hold replicas, there are significant benefits while selecting the best replica. In this paper, we propose a new replica selection strategy based on classification techniques. In this strategy the replica selection problem is regarded as a classification problem. The data transfer history is utilized to help predicting the best site holding the replica. The adoption of the switch mechanism of replica selection model avoids a waste of time for inaccurate classification results. In this paper, we study and simulate KNN and SVM methods for different file access patterns and compare results with the traditional replica catalog model. The results show that our replica selection model outperforms the traditional one for certain file access requests.

Querying about the time-varying locations of moving objects is particularly cumbersome in environments composed of a very large number of distributed spatio-temporal database servers. In particular, searching for a specific object can require to visit each server. In this paper we propose a strategy to avoid such an exhaustive search that is based on the use of a centralized index, called

meta-index

, which is the entry point for spatio-temporal search queries. This index allows a software agent to determine a search plan for visiting the most likely servers to contain the target object. An important issue for large and dynamic distributed servers systems is to keep the meta-index as up-to-date as possible with the real system. This paper defines and compares two different strategies for maintaining properly updated the meta-index:

crawling

, where the centralized system that keeps the index controls itself the updating process, and

harvesting

, where each distributed database server autonomously transfers data directly into the central index system. Both strategies were implemented and compared by using discrete-event simulators with demanding synthetic spatio-temporal data. The results show that crawling has better performance.

Deployment of distributed applications on large systems, and especially on grid infrastructures, becomes a more and more complex task. Grid users spend a lot of time to prepare, install and configure middleware and application binaries on nodes, and eventually start their applications. The problem is that the deployment process is composed of many heterogeneous tasks that have to be orchestrated in a specific correct order. As a consequence, the automatization of the deployment process is currently very difficult to reach. To address this problem, we propose in this paper a generic deployment framework allowing to automatize the execution of heterogeneous tasks composing the whole deployment process. Our approach is based on a reification as software components of all required deployment mechanisms or existing tools. Grid users only have to describe the configuration to deploy in a simple natural language instead of programming or scripting how the deployment process is executed. As a toy example, this framework is used to deploy CORBA component-based applications and OpenCCM middleware on one thousand nodes of the French Grid5000 infrastructure.

From the computational point of view, Content-based Im- age Retrieval systems are potentially expensive and have user response times growing with the ever-increasing sizes of the databases associated to them. This paper presents a grid implementation of a Content-based Image Retrieval system that offers a good cost/performance ratio to solve this problem due to their excellent flexibility, scalability and fault tolerance. This approach allows a dynamic management of specific data- bases that can be incorporated to or removed from the CBIR system in function of the desired user query. Experimental performance results are collected in order to show the feasibility of this solution.

Group communication is an important paradigm for fault tolerance in large scale systems. We describe various group architectures as pipelined, hierarchical, daisy and hypercube groups each consisting of separate clusters, investigate the theoretical performance bounds of these architectures and evaluate their experimental performances using MPI group communication primitives. We first derive time bounds for multicast message deliveries in these architectures and then provide tests to measure the times taken for the same operation. The multicast message delivery times are tested against the number of clusters within a group and the size of the multicast message. We conclude that daisy architecture is favorable both in terms of delivery times and message sizes theoretically and experimentally.

Welcome to the Eighth International Symposium on Distributed Objects and Applications (DOA 2006). This year DOA was held in Montpellier, France, from October 30 to November 1, 2006.

The DOA conferences provide a forum for exchanging the latest research results on distributed objects, components, services, and applications. Research in distributed objects, components, services, and applications establishes new principles that open the way to solutions that can meet the requirements of tomorrow’s applications. Conversely, practical experience in real-world projects drives this same research by exposing new ideas and posing new types of problems to be solved. With DOA 2006 we explicitly intended to provide a forum to help this mutual interaction occur, and to trigger and foster it. Submissions were therefore welcomed along both these dimensions: research (fundamentals, concepts, principles, evaluations, patterns, and algorithms) and practice (applications, experience, case studies, and lessons). Contributions attempting to cross over the gap between these two dimensions were particularly encouraged. Towards this goal, we accepted both research and experience papers.

Information and communication technologies seamlessly and invisibly pervade into everyday objects and environments, delivering services through the ’things’ (artefacts) of the physical world, and adapted to the context of their use. As an approach to link each artefact in the physical world with the software objects in the digital world we propose ’everyobjects’, the symbiosis of technology rich artefacts and a P2P based coordination framework.

A spatial proximity based spontaneous interaction approach for ’shared nothing’ P2P systems has been developed and implemented in our P2P coordination framework. Mobile peers, once in spatial proximity to each other, coordinate their activities based on the exchange and analysis of self descriptions in metadata format. Each peer individually conducts a similarity analysis of the role and profile data received from other peers in vicinity, and invokes triggers if a certain similarity threshold is reached. I will present aspects of the underlying profile description language expressing peer preferences with respect to the particular context in which the interaction is attempted (like time, geoposition, owner, environmental conditions, etc.), the mathematical formulation of similarity metrics and the matching analysis of semistructured data, the mechanisms for consensus finding and coordination in peer ensembles, and the component model within which the framework is implemented. Findings will be demonstrated in scenarios involving our ’Peer-it’ miniaturized hardware platform, serving as a stick-on solution for artefacts.

This paper proposes the use of

Selective Acknowledgements

(SACK) from clients to services as a method for reducing the memory footprint of replicated services. The paper discusses the general concept of SACK in replicated services and presents a specific implementation of SACK for an existing replication infrastructure. Performance measurements exhibiting the effectiveness of SACK are also presented.

With the adoption of Web services technology to realize Service Oriented Architectures, the need arises for more flexible and dynamic technologies for the just-in-time integration and composition of services. As the runtime integration, selection and management of services involves a variety of crosscutting concerns, such as error handling, service monitoring, and QoS enforcements, Aspect Oriented Programming (AOP) is useful to modularize such concerns.

In this paper we investigate aspect-oriented support for crosscutting concerns of distributed management of web service compositions. We propose to use a distributed AOP approach, Aspects with Explicit Distribution (AWED), to modularize such concerns in a distributed variant of the Web Services Management Layer (WSML). Concretely, we present three contributions. First, we present an extension of the WSML to distributed compositions. Second, we present two extensions to AWED’s aspect language which are useful for the modularization of crosscutting concerns of web services: support for chains of (a)synchronous remote advice that communicate through futures, and support for different modes of parameter passing between remote pointcuts and advice. Third, we illustrate our approach by investigating error handling in distributed web compositions.

The development of highly dynamic distributed environments modifies the runtime behavior of applications. Applications tend to use services available everywhere in the environment and would like to, whenever it is possible and/or needed, integrate services offered by the local environment. In particular, if no single service can satisfy the functionality required by the application, combining existing services together should be a possibility in order to fulfill the request.

In this article, we propose

ANIS

: A Negotiated Integration System. Our system provides a framework including a set of integration management interfaces –

Integrable

,

Negotiable

,

IntegrationLifeCycle

– and the tools implementing these interfaces. These tools offer different techniques of integration (local/remote composition, local/remote weaving, deployment by downloading/uploading), negotiation by contracts and the capability to manage the life cycle of the integration.

A prototype based on Java platform and OSGi technology is implemented as a proof-of-concept to demonstrate the potential of ANIS.

View synchronous group communication is a mature technology that greatly eases the development of reliable distributed applications by enforcing precise message delivery semantics, especially in face of faults. It is therefore found at the core of multiple widely deployed and used middleware products. Although the implementation of a group communication system is a complex task, application developers may benefit from the fact that multiple group communication toolkits are currently available and supported.

Unfortunately, each communication toolkit has a different interface, that differs from every other interface in subtle syntactic and semantic aspects. This hinders the design, implementation and maintenance of applications using group communication and forces developers to commit beforehand to a single toolkit, thus imposing a significant hurdle to portability.

In this paper we propose jGCS, a generic group communication service for Java, that specifies an interface as well as minimum semantics that allow application portability. This interface accommodates existing group communication services, enabling implementation independence. Furthermore, it provides support for the latest state-of-art mechanisms that have been proposed to improve the performance of group-based applications. To support our claims, we present and experimentally evaluate implementations of jGCS for several major group communication systems, namely, Appia, Spread/FlushSpread and JGroups, and describe the port of a large middleware product to jGCS.

Supporting advertisements in large publish/subscribe services has an improving influence on the system scalability. The additional application of event routing optimizations based on subscriptions further increases the event throughput and decreases the memory usage of publish/subscribe systems. However, also advertisement-based optimizations can improve these system properties but have been widely neglected so far. In particular, no current optimizations are applicable to advertisements defined as arbitrary Boolean filter expressions.

In this paper, we outline the final milestone on the way to practically support the arbitrary Boolean publish/subscribe model: We firstly develop a novel optimization approach, advertisement pruning, that is tailored to arbitrary Boolean advertisements. Secondly, we present a detailed evaluation of the optimization potential of this advertisement-based solution. We finally analyze the effects of additionally optimizing subscriptions on the advertisement pruning optimization.

Implementing overlay software is non-trivial and time-consuming. Current projects build overlays or intermediate frameworks on top of low-level networking abstractions. This leads to far reaching incompatibilities between overlay implementations, tight coupling to frameworks and limited adaptability to different deployment environments.

We present a new approach to rapid overlay implementation that combines a modelling framework for overlay design with a dynamic component architecture for run-time adaptation. It is the first architecture in the overlay area that tackles the complete design process from modelling, through code generation and implementation down to adaptive deployment. To demonstrate the effectiveness of this architecture, we describe the step-by-step procedure of designing an overlay and deploying it within an adaptive middleware framework.

Various peer-to-peer (P2P) architectures for ad-hoc networks have been proposed over the last few years. Most of them are unstructured and use some form of flooding to locate content, because the physical constraints of the underlying network make the construction of arbitrary application-layer overlays impractical.

In this paper, we study the problem of applying distributed hash tables (DHT) to ad-hoc networks. Our approach to efficiently lookup content in such networks exploits physical proximity of peers when establishing and maintaining the DHT based routing tables. The efficiency of our method is demonstrated by simulation of large networks.

This paper presents a framework for building and managing compound documents in distributed systems. It enables an enriched document to be dynamically and nestedly composed of software components corresponding to various types of content, e.g., text, images, and windows. It permits the content of each component and program code to access the content inseparable inside the components so that the components can be viewed or modified without the need for any applications. It enables each component or document to migrate over a network under its own control by using mobile agent technology. Moreover, it introduces components as carriers or forwarders because it enables them to carry or transmit other components as first class objects to other locations. It offers several basic operations for network processing, e.g., forwarding, duplication, and synchronization. Since these operations are still document components, they can be dynamically deployed and customized at local or remote computers through GUI manipulations. It therefore allows an end-user to easily and rapidly configure network processing in the same way as if he/she had edited the documents. This paper describes the framework and its implementation, which currently uses Java as the implementation language as well as a component development language, and then illustrates several interesting applications that demonstrate its utility and flexibility.

We describe a range of designs for supporting rich search queries in a peer-to-peer network. Our implementation is based upon uniquely identified data objects which are replicated upon request by agents called Shepherds. Several abstract data structures are built upon this framework, supporting dataset management, lexical search, and distributed GIS interfaces in an application called the Geobrowser. Our results demonstrate that it is possible to layer higher-level data structures upon a basic peer-to-peer transport and replication layer. When users perform a given query, parts of the index as well as the query results themselves are shepherded to the user’s local venue. A natural benefit of this approach is that mobile users can repeat previous searches if they become disconnected from the rest of the network. Some of the data structures that prove to be successful are peer-to-peer adaptations of traditional indexing structures. We review some of the properties that lead to successful designs in this domain, giving examples of deployed systems in the Geobrowser.

In this paper we introduce the concept of

Distributed Abstract Data Type

(

dadt

), a new programming model simplifying the development of distributed, context-aware applications. A

dadt

instance logically encapsulates a collection of

adt

instances distributed throughout the system.

dadt

operations specify the semantics of access to this distributed state by using dedicated programming constructs. The scope of these operations can be restricted using

dadt

views

, i.e., projections over the target

adt

instances, defined declaratively and dynamically based on

adt

properties. Interestingly,

dadt

constructs can be used to deal not only with application data, but also with the space where it resides. This leads to a uniform treatment of the data and space concerns, simplifying the development of context-aware applications and providing the programmer with considerable flexibility and expressive power. We argue that

dadt

s are amenable to incorporation in existing object-oriented programming languages, as demonstrated by our prototype implementation.

In our service engineering approach, services are specified by UML 2.0 collaborations and activities, focusing on the interactions between cooperating entities. To execute services, however, we need precise behavioral descriptions of physical system components modeling how a component contributes to a service. For these descriptions we use the concept of state machines which form a suitable input for our existing code generators that produce efficiently executable programs. From the engineering viewpoint, the gap between the collaborations and the components will be covered by UML model transformations. To ensure the correctness of these transformations, we use the compositional Temporal Logic of Actions (cTLA) which enables us to reason about service specifications and their refinement formally. In this paper, we focus on the execution of services. By outlining an UML profile, we describe which form the descriptions of the components should have to be efficiently executable. To guarantee the correctness of the design process, we further introduce the cTLA specification style cTLA/e which is behaviorally equivalent with the UML 2.0 state machines used as code generator input. In this way, we bridge the gap between UML for modeling and design, cTLA specifications used for reasoning, and the efficient execution of services, so that we can prove important properties formally.

Nowadays, distributed and mobile systems are acquiring greater importance and becoming more widely used to support ubiquitous computing. However, developing systems of this kind is a difficult task. Instead of concentrating on how problems should be solved developers must worry about implementation details. Ambient Calculus is a formalism that provides primitives to describe mobile systems in an abstract way. Aspect-oriented software development and software architectures promise to achieve reusability, maintenance and adaptability, which are all essential for the development of distributed systems. In this paper, we present how a platform-independent model called Ambient-PRISMA combines both Ambient Calculus and Aspect-Oriented Software Architecture for the specification of distributed and mobile systems. A platform-specific model in .Net for supporting Ambient-PRISMA code generation is also presented.

The explicit consideration of component contracts aims at simplifying the development of component-based applications with non-functional requirements like QoS and security, but it is also a challenging task. QoS contract negotiation is used to select concrete QoS contracts between the collaborating components. This paper presents an algorithm for the QoS contract negotiation of components deployed in multiple component containers. Our algorithm addresses: possible resource constraints at each node and the network, the efficiency of the negotiation process, the selection of a heuristically optimized solution, and over-constrained cases. As a basis to our approach, we used the notion that the required and provided non-functional properties as well as resource demand are specified at the component level. To demonstrate the presented ideas, the interaction of a customer, video provider, and payment provider example scenario is analyzed.

Initially targeted at supporting individual work, personal devices are more and more used for collaborative activities in mobile environments. In this context, service continuity raises the problem of data availability during disconnections. This relies on optimistic replication with the deployment of a local copy of the necessary application components, leading to potential divergence of the distributed copies. Consequently, the main challenge consists in designing reconciliation mechanisms in order to synchronize copies at reconnection time. In this paper, we present RIMoCoW (Reconciliation Infrastructure for Mobile Collaborative Work) a reconciliation infrastructure designed and implemented for CORBA component-based applications in a mobile collaborative work environment. RIMoCoW follows a service-based approach and integrates SOCT4Mob (Serialization of Concurrent Operations by Transposition in Mobility) a synchronization algorithm we have extended for the mobile context. In addition, we propose recovery and sequencer related policies that fit to mobile requirements. Finally, RIMoCoW is implemented using an emergency management application. The performance results show that our infrastructure can reconcile in roughly 30 minutes more than 16.000 victims medical files filled by 8.000 rescuers, which corresponds to a level of 6 on a 6-degree European scale for technological accidents.

Recently, many researchers have focused on designing generic and reusable middlewares to overcome the complexity in building adaptive systems. There is a general agreement that the openness provided by component-based approaches coupled with reflection mechanisms is the minimum prerequisites for supporting dynamic reconfigurations. However, this is not sufficient to implement the heart of the adaptation loop namely the decision making on the required reconfiguration that adapts the system in a given context. In this regard, this paper proposes a planning framework that subsumes and automates the adaptation decision-making in reflective component-based adaptive systems. The salient feature of this framework is to model the variability of the adaptive system as a set of variation points at which alternative component compositions and implementations can be selected to form an application configuration. The selection of a feasible configuration in a given context is based on the concept of component wise utility functions that estimates the user benefit of including a specific implementation alternative at a variation point in the composition. We show that the selection problem can be modelled as a multi constraint shortest path that can be found in polynomial time. Our approach is validated through a real world example implementing adaptive scenarios in the domain of mobile computing.

Much work has been done in order to make the development of distributed systems as close as sensible to the development of centralized systems. As a result, there are today good distributed object solutions that closely resemble centralized programming. However, this very attempt to mimic centralized programming implies that distributed objects create the illusion that threads traverse the whole distributed application. This brings all the problems related to multi-thread programming, including the need to reason about the thread behavior of the

whole

application, which gets amplified by the large scale and inherent non-determinism of distributed systems. Moreover, distributed objects present other troubles when the application is not pure client-server, i.e., when the client has other things to do besides waiting for the server.

As an alternative, there are a number of message-based non-blocking communication solutions. Unfortunately, these solutions were not designed to directly address the above mentioned issue of multi-threading over the whole distributed application. In addition: (i) these solutions are not as well integrated to the programming language as distributed objects, and (ii) most of them do not provide a well-defined embedded failure detection mechanism, something that is crucial for the development of many distributed systems, and that is well solved by distributed objects (as they couple method invocation and failure detection).

We here propose and evaluate an improvement for such a status-quo, named JIC (Java Internet Communication). JIC is an event-driven middleware that relies on a non-blocking communication model, yet providing close semantics to the object-oriented paradigm. JIC is designed to combine the best characteristics of distributed objects and message-based solutions. For instance, JIC defines precise scope for the application’s threads, promotes non-blocking communication, provides a failure detection service that is simple to use with precise semantics, and has performance comparable to Java RMI. Furthermore, JIC is designed to be firewall and NAT friendly, greatly helping the deployment of JIC-based applications across multiple administrative domains.

Many programming models have been proposed to facilitate the development of context-aware applications. However, previous work does not offer support for building customised systems and has largely been targeted at a single application domain. In this paper, we describe MoCoA, a flexible middleware framework that permits the rapid development of context-aware applications and supports deployment scenarios ranging from augmented artefacts to city-wide smart-space applications. Crucially, MoCoA supports a small set of programming abstractions that are suitable for building a wide range of context-aware applications for deployment in a fixed or (ad hoc) mobile environment. For each of these abstractions, MoCoA provides a set of implementations via a library of components. We present three applications of the MoCoA framework that demonstrate both the use of the programming abstractions and the flexibility of the framework.

The majority of object migration systems do not support heterogeneous environments. Few systems solve this challenge by specifying a platform and language independent state transfer format, requiring a compatible implementation for every target language. However, fields of research like Ubiquitous and Pervasive Computing with mobile users and applications demand an even more platform-independent, flexible and adaptive approach.

This paper presents a novel approach for adaptive object and agent migration in heterogeneous environments based on our former work enabling language- and platform-independent object mobility in CORBA. By providing flexible mechanisms to reduce, expand and transform an object’s state and functionality during migration, we support adaptation to the context and application-specific demands at the target system.

This is achieved by introducing a separation of state, functionality and implementation code instead of mapping particular state on particular code. Our prototype system supports object migration from Java to C++ and vice versa. In principle, our concept can be transferred to any CORBA-supported programming language.

Efficient resource management is a great concern for many enterprise developers. One of the most important resources that should be carefully managed is the amount of memory consumed by applications. This paper proposes a novel distributed memory management framework, namely Distributed Object Pool Service (DOPS) which efficiently manages the lifecycle of entity objects in distributed systems. The generality and scalability of DOPS makes it reusable for any commercially distributed middleware, such as CORBA and COM+. In addition, since there is no absolute proper configuration to be used efficiently for object pools of any software system, we offer a workload simulator which simulates target systems in order to find the appropriate configuration for them. Using our workload simulator, we conduct several experimental tests using CORBA. These experimentations demonstrate the effectiveness of DOPS including the positive affect of dynamic sizing of object pools and the productivity of preparing fine-granularity configuration facilities.

We present the design of core mechanisms for building interoperable runtime module systems. Runtime modules are the cornerstone of component platforms, such as Eclipse Rich Client Platform or Apache Geronimo, since they provide components with their namespace for Java classes and resources. Unfortunately, much diversity exists today regarding module systems, thereby hindering the creation of a global Java ecosystem for components. Our approach proposes a first step towards a solution since our design can model and integrate different module systems such as traditional Java class loaders, Geronimo Beans, or the OSGi framework. We propose low-level core mechanisms, both modular and flexible, that enables building such module systems from reusable and adaptable mechanisms. Furthermore, once module systems are built with our core mechanisms, our approach enables their integration within a single runtime environment. This is especially important at a time where different open-source component platforms, as well as the products built upon them, are facing the integration challenges between heterogeneous module systems. Our design is the basis of the current implementation of Felix, within the Apache community; it illustrates an integration path towards a global Java ecosystem for components.

Code offloading is a promising effort for embedded systems and load-balancing. Embedded systems will be able to offload computation to nearby computers and large-scale applications will be able to load-balance computation during high load. This paper presents a runtime infrastructure that transparently distributes computation between interconnected workstations. Application source code is not modified: instead, dynamic aspect weaving within an extended virtual machine allows to monitor and distribute entities dynamically. Runtime policies for distribution can be dynamically adapted depending on the environment. A first evaluation of the system shows that our technique increases the transaction rate of a Web server during high load by 73%.

Developing distributed applications for sensor/actuator networks is challenging, particularly, with regard to unreliable nodes and communication links. Splitting applications into roles eases the development significantly but presumes a reliable role management that autonomously assigns roles to devices depending on their capabilities. In this paper, we present a self-organizing and self-stabilizing role assignment mechanism as an integral part of a light-weight, flexible middleware. The deployed algorithms tolerate the addition and removal of devices at runtime and are also able to recover from any transient fault. Considering that resources are restricted on many devices, we analyze the proposed algorithms with respect to communication overhead, memory usage, and stabilization time.

Efficient multi-receiver delivery of video data over computer networks, such as the Internet is still challenging, due to heterogeneity in involved network technologies, end-node capabilities and receiver preferences. While adaptive and scalable video encoding can solve many of the problems caused by heterogeneity, media gateway systems are needed for performing video filtering and transformation in order to handle cases not solved by scalable coding. The complexity of such systems makes them difficult to manage by humans. Hence streaming media delivery systems, including media gateway systems should be self-managed only guided by policies provided by system managers and users.

In this paper, we describe a media gateway systems framework for developing binding managers for gateway-based stream bindings. These bindings construct an overlay network for media stream distribution. The framework is open, enabling insertion of specific binding policies that suits particular user preferences. Our framework contributes towards self-management of multi-user streaming services by supporting self-configuration and re-configuration of multi-receiver bindings. It also contributes to easier development of business streaming applications by supporting the plugging in of binding policies targeting particular application domains. We describe the implementation of a prototype of the framework and evaluate the framework by observing and comparing the effect on the property of bindings when different binding policies are applied. Finally we discuss issues of gateway service placement when bindings are deployed in a large scale infrastructure.

Middleware is increasingly used to develop and deploy compo nents in enterprise distributed real-time and embed ded (DRE) systems. A key chal lenge in these systems is de vising resource management algorithms that deploy appli cation components properly onto target nodes. To provide an accurate view of system re source utilization, these algorithms need monitor resources at runtime. Runtime resource monitoring is also needed to make redeployment or reconfigu ration decisions trig gered by various factors, such as failures, attacks, overloads, or changes in quality of service (QoS) re quirements. DRE sys tems with a diverse range of applications can therefore benefit from a common re source provisioning service capable of monitoring re source data and ena bling proper resource allocation in a timely manner.

This paper provides two contributions to the study of run time resource provi sioning for enterprise DRE systems. First, it describes the challenges in devel oping

Bulls-Eye

, which is an open implementation of the OMG standard Target Manager specification that provides a reusable service for provisioning distrib uted resources in enter prise DRE systems. Second, it presents the results of ex periments that applied

Bulls-Eye

to the multi-layer resource manage ment sub system of a ship board computing environment. Our re sults show that provi sioning re sources at runtime in a DRE system via

Bulls-Eye

simplifies resource manage ment and helps automate adaptations in the face of dynamic changes in operat ing conditions.