A Lightweight Reliable Object Migration Protocol

2009

Abstract The fundamental ideas of distributed objects have changed little in the last 20 years. Existing languages are retrofitted with transparent distribution mechanisms based on proxies. Experiments with mobile code demonstrate its power but have little impact on practice. The problems with transparency and mobile code have been well known since at least 1994. But in the absence of any fundamental new ideas, the same problematic approaches are used, for example in the design of Java RMI.

1988

1996

Programming of distributed applications is now supported by multiple alternatives when considering high level distributed environments. Using a system platform for remote access to services Such a platform can be a pure distributed operating system or a distributed language runtime like Emerald[1], Argus[2] , Guide[3] , or a platform that integrates distribution like CORBA[4], ILU[5] , Network OLE, etc. Those technologies aim at providing transparent and easy access to distributed services available on a workstation cluster, thus normalizing the way of accessing them. Such a normalization most often deals with the interface description language (IDL[6]) that statically describe services available from various objects, and the mapping of such a language with existing programming languages used for the core implementation of objects. In order to access a service, a client object must first know the identity of the server object (that really provides the desired service), the type of interface that can be dynamically accessed. Then the client object submits a request to the system platform that handles the search for the server, the execution of the request and the delivery of the results. In contrast with this rather static approach, message busses[7][8] are providers of distributed access to dynamically declared services. A client requesting a service is

Lecture Notes in Computer Science

This paper describes abstractions that have been designed to support distributed programming in the object oriented programming language BETA. The approach is minimalistic in the sense that a goal is to provide the essential building blocks on top of which other distribution related abstractions may be built. This goal is made easier by demanding for type orthogonal persistence and distribution as the full power of the underlying language may then be used when building higher level abstractions on top of the basic ones.

Lecture Notes in Computer Science, 2005

In the age of the world-wide web and mobile computing, program- ming communication-centric software is essential. Thus, programmers and pro- gram designers are exposed to new levels of complexity, such as ensuring the correct composition of communication behaviours and guaranteeing deadlock- freedom of their protocols. This paper proposes the language Ldoos, a simple distributed object-oriented language augmented with session communication

2005

Strong mobility enables migration of entire computations combining code, data, and execution state (such as stack and program counter) between sites of computation. This is in contrast to weak mobility were migration is confined to just code and data. Strong mobility is essential for many applications where reconstruction of execution states is either difficult or even impossible. Typical application areas are load balancing, reduction of network latency and traffic, and resource-related migration, just to name a few. This thesis presents a model, programming abstractions, an implementation, and an evaluation of thread-based strong mobility. The model extends a distributed programming model based on automatic synchronization via dataflow variables. The programming abstractions capture various migration scenarios. These scenarios differ in how migration source and destination relate to the site initiating migration. The implementation is based on replication of concurrent lightweight...

Lecture Notes in Computer Science, 2006

This paper shows that asynchronous fault detection is a practical way to reflect partial failure in a network-transparent distributed programming language. In the network-transparency approach, a program can be distributed over many sites without changing its source code. The semantics of the program's execution does not depend on how the program is distributed. We have experimented with various mechanisms for detecting and handling faults from within the language Oz. We present a new programming model that is based on asynchronous fault detection, is more consistent with the network-transparent nature of Oz, and improves the modularity of failure handling at the same time.

New Generation Computing, 1998

Much progress has been made in distributed computing in the areas of distribution structure, open computing, fault tolerance, and security. Yet, writing distributed applications remains difficult because the programmer has to manage models of these areas explicitly. A major challenge is to integrate the four models into a coherent development platform. Such a platform should make it possible to cleanly separate an application’s functionality from the other four concerns. Concurrent constraint programming, an evolution of concurrent logic programming, has both the expressiveness and the formal foundation needed to attempt this integration. As a first step, we have designed and built a platform that separates an application’s functionality from its distribution structure. We have prototyped several collaborative tools with this platform, including a shared graphic editor whose design is presented in detail. The platform efficiently implements Distributed Oz, which extends the Oz language with constructs to express the distribution structure and with basic primitives for open computing, failure detection and handling, and resource control. Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Oz is based on a higher-order, state-aware, concurrent constraint computation model.

We hav e developed the Object Space approach which integrates that communication style with object-oriented techniques. It allows encapsulation of protocols for interactions in distributed applications into classes, thus providing a newlev elofabstraction.

Communications of The ACM, 1993

istributed object-oriented programming languages have proved to be superior to other known approaches for the development of complex distributed applications. Most of these languages support location-independent method invocation and object migration. Together with the fine granularity of objects, these features allow distributiontransparent modeling and programming.

Microprocessing and Microprogramming, 1993

bDpt. Lenguajes y Ciencias de la Computaci6n. Universidad de M::ilaga. El Ejido, s/n. 29013 M,'ilaga. SPAIN.

2001

This thesis explores computation mobility. We view mobility, the selection of an execution environment, as an attribute of a computation. To capture this attribute, we introduce a novel programming abstraction, which we call a mobility attribute, that specifies where computations should occur within a distributed system. Programmers dynamically bind mobility attributes to program components, nonempty sets of functions and their state. Once bound to a component, mobility attributes apply prior to each execution of that component.

1991

The popularity of the object oriented programming paradigm has stimulated research into its use for parallel and distributed programming. The major issues which impact such use are concurrency control, object interfaces, binding and inheritance. This paper discusses the relative merits of current solutions to these issues and describes an approach based on the use of active objects with essentially explicit interfaces and bindings, and composition as a pragmatic alternative to inheritance. The key feature of our approach is the use of a configuration language to define program structure as a set of objects and their bindings. The configuration language includes facilities for hierarchic definition of composite objects, for parameterisation of objects, for replication of both object instances and interface interaction points, for conditional configurations with evaluation of guards at object instantiation, and even for recursive definition of objects. This separate and explicit description of program structure complements the object oriented concepts yet is missing from most other approaches. This approach, termed Configuration Oriented Programming, is illustrated by examples from the REX environment for the development of distributable software. This environment is being developed by the REX collaborative ESPRIT II project [REX 89].

Object-Orientation …, 1995

This paper presents a new algorithm for supporting fault tolerant objects in distributed object oriented systems. The fault tolerance provided by the algorithm is fully user transparent. The algorithm uses checkpointing and message logging scheme. However the novelty of this scheme is in identifying the checkpointing instances such that the checkpointing time will not a ect the regular response time for the object requests. It also results in storing the minimum amount of object state(object address space). A simple message logging scheme that pairs the logging of response message and the next request message reduces the message logging time by half on an average compared to other similar logging schemes. The scheme exploits the general features and concepts associated with the notion of the objects and object interactions to its advantage.

1999

This paper presents an object-oriented distributed language, called CUBLqq, that is a powerful tool for developing distributed applications on heterogeneous computer networks. CUBLqq is based on objects, called c units, that communicate through synchronous and asynchronous message Ž . Ž . passing. A c unit is an active object composed of data state and procedures as traditional passive objects, together with the capability of queueing incoming messages, when needed. C units allow a programmer to implement an application on a heterogeneous architecture, as they communicate with each other without taking into account the physical characteristics of the actual node where they are located. We have experimented CUBLqq on a network where UNIX workstations, WindowsNT personal computers and transputers cooperate in order to perform a given task. In particular, this paper gives a brief description of a distributed system for image processing that has been implemented by using CUBLqq.