The goal of this work is to provide uniform transparent access to objects, be they local, remote, persistent, or mobile. In this way, we facilitate distributed programming and persistence management. An object (the target) is accessed through a reference. A reference retains its meaning as it is copied, stored, passed in messages, and as the target migrates. A reference is used to invoke a procedure (or method) of the target object. References support standard single-space targets, as well as fragmented objects [9]. The cost of using a reference to a local object is comparable to the cost of accessing the object through a pointer. In the implementation, a reference is a chain of links. Each link embodies a small piece of functionality. A chain may be composed of an arbitrary number of links.

Fragmented Objects offer an interesting alternative to the use of uniform transparent object references in distributed systems. This novel paradigm for distributed programming provides facilities for the encapsulation of policy issues, as well as implementation details such as communication mechanisms and consistency requirements. At the same time a clean and comprehensible model is offered to both FO designers and client programmers. A number of omissions in earlier papers on this topic are rectified here, and certain mechanisms are generalised to increase both the power and the expressiveness of the model. In particular, FO interfaces are extended to include upcalls and a new internal model, based on the fragment factory, is introduced. 1 Introduction Fragmented Objects were first introduced as a result of work on the SOS system [14] and elaborated in [8]; for an accessible overview of the concept see [7]. We present here a refinement of the idea, which originated in Shapiro's Proxy...

Programming distributed applications supporting data sharing is very hard. In most middleware platforms, programmers must deal with system-level issues for which they do not have the adequate knowledge, e.g., object replication, abusive resource consumption by mobile agents, and distributed garbage collection. As a result, programmers are diverted from their main task: the application logic. In addition, given that such system-level issues are extremely error-prone, programmers spend innumerous hours debugging. We designed, implemented, and evaluated a middleware platform called OBIWAN that releases the programmer from the above mentioned system-level issues. OBIWAN has the following distinctive characteristics: 1) allows the programmer to develop applications using either remote object invocation, object replication, or mobile agents, according to the specific needs of applications, 2) supports automatic object replication (e.g., incremental on-demand replication, transparent object faulting and serving, etc.), 3) supports distributed garbage collection of useless replicas, and 4) supports the specification and enforcement of history-based security policies well adapted to mobile agents needs (e.g., preventing abusive resource consumption).

Distributed scalable garbage collectors, mostly based on some kind of reference counting, fail to detect distributed cycles of garbage. This problem may lead to important memory leaks in distributed storage systems. In this paper, we present a new algorithm which detects and collects such distributed cycles of garbage. Our algorithm is based on the propagation of marks along chains of remote pointers. It uses two new mechanisms: rain-max marking, to propagate two different marks to each stub, and sub-generation, to build an acyclic graph on a cycle using back-tracking information. A new technique, called optimistic back-tracking, is also used to speed-up subgeneration. The resulting algorithm is completely distributed, asynchronous, fault-tolerant and inexpensive. Moreover, it collects incrementally all distributed cycles of garbage, without partitioning the system. Thus, it is particularly well adapted to large-scale networks. Finally, it can be easily implemented with minor modifications of a local tracing garbage collector.

We propose a generic framework for storage support in a distributed environment. This comprises a set of storage abstractions and storage policies: data clusters, cluster containers, and container domains, supporting sharing, caching, and replication. These abstractions and these policies are structured as fragmented objects (FOs), such that each storage system designer can offer the appropriate tradeoffs to its targeted applications. The core set of abstractions is discussed, their interfaces are presented, and the FOstructuring of the cluster abstraction is detailed. 1 Introduction Despite the availability of a large number of distributed storage systems, for a number of reasons there is still a need to design new ones. One reason is to explore new technologies, such as disks arrays [1]. Another is because of evolving application needs. Finally, this is to combine into a single system interesting features implemented by different storage systems. A brief survey of existing storage s...