Transport Mode Detection (TMD) systems play a pivotal role in facilitating applications in transport, urban planning, and more. Exploiting the advancements in smartphone sensing capabilities, TMD systems have evolved for mobile applications with local classification on smartphones as a common approach. Yet, local approaches relying on centralized training raise privacy concerns due to the transmission of sensitive data (e.g., GPS logs) over the Internet. In this paper, we propose FogFLeeT, a novel Federated Transfer Learning (FTL) framework for TMD, addressing both privacy and performance concerns. Our approach relies on Federated Learning (FL) to train a global model on various datasets from different cities while employing transfer learning to adapt the global model to the specific characteristics of individual smartphones and cities. FogFLeeT relies on an architecture that integrates edge, fog, and cloud layers, with dedicated fog nodes for each city to simplify cross-silo federated learning. Experimental results demonstrate the effectiveness of the FogFLeeT framework in higher TMD accuracy by up to 20% than its comparable centralized approach. Furthermore, it outperforms the FL solutions reported in the literature with at least an 8% increase in accuracy. In this work, we also highlight the importance of sufficient training data for distributed training and discuss the impact of smartphone sensor qualities on the performance of TMD systems. Our work contributes to advancing TMD systems by providing an adaptive and privacy-preserving solution suitable for deployment in diverse urban environments and across various geographical locations.

This paper explores automatic heap sizing where developers let the frequency of GC expressed as a target overhead of the application's CPU utilisation, control the size of the heap, as opposed to the other way around. Given enough headroom and spare CPU, a concurrent garbage collector should be able to keep up with the application's allocation rate, and neither the frequency nor duration of GC should impact throughput and latency. Because of the inverse relationship between time spent performing garbage collection and the minimal size of the heap, this enables trading memory for computation and conversely, neutral to an application's performance.

A user’s transport mode (e.g., walk, car, etc.) can be detected by using a smartphone. Such devices exist in a great number with enough computation power and sensors to run a classifier (i.e., for transport mode detection). Using a smartphone in a fog environment ensures low latency, high generalization, high accuracy, and low battery consumption. We propose a fog-based real-time (at human time scale) transport mode detection, called FogTMDetector; it consists of a Random Forest classifier trained with magnetometer, accelerometer, and GPS data. The overall accuracy achieved by our system is 93% when detecting 8 different modes (i.e., stationary, walk, bicycle, car, bus, train, tram, and subway). We compared FogTMDetector with another recent system (called EdgeTrans). The comparison results suggest that our solution achieves 10% higher motorized accuracy (i.e., 94.4%) with more fine-grained motorized transport modes (i.e., subway, tram, etc.) thanks to the magnetometer sensor readings. FogTMDetector uses a low sampling rate (1Hz) for logging accelerometer and magnetometer and (every 10 seconds) for GPS to ensure low battery consumption. FogTMDetector is also generalizable as it is robust against variation of users and smartphone positions.

Garbage collection (GC) solutions are widely used in programming languages like Java. Such GC solutions follow prioritized goals and behave differently regarding crucial performance metrics like pause time, throughput, and memory usage. Consequently, running an application using each GC would have an evident impact on the application’s performance, especially on those dealing with massive data and tons of transactions. Nevertheless, it is challenging for a user/developer to pick a GC solution that fits an application’s performance goals. However, surprisingly, there is no tool to help a user/developer on this matter. In this study, we follow an effective methodology to build a heuristic combining throughput and pause time, with diverse heap sizes available, to score four production GCs (G1, Parallel, Shenandoah, and ZGC). Then we propose a system, BestGC, which offers the most suitable GC solution for a user application taking into account the performance goals of the user application.

Abstract We present a survey of smartphone-based Transport Mode Detection (TMD). We categorize TMD solutions into local and remote; the first ones are addressed in this article. A local approach performs the following steps in the smartphone (and not in some faraway cloud servers): 1) data collection or sensing, 2) preprocessing, 3) feature extraction, and 4) classification (with a previous training phase). A local TMD approach outperforms a remote approach due to less delay, improved privacy, no need for Internet connection, better or equal accuracy and smaller data size. Therefore, we present local TMD solutions taking into account the above mentioned four steps and analyze them according to the most relevant requirements: accuracy, delay, resources consumption and generalization. To achieve the highest accuracy (100%), studies used a different combination of sensors, features and Machine Learning (ML) algorithms. The results suggest that accelerometer and GPS (Global Position System) are the most useful sensors for data collection. Discriminative ML algorithms, such as random forest, outperform the other algorithms for classification. Some solutions improved the delay of the proposed system by using a small window size and a local approach. A few studies could improve battery usage of their system by utilizing low battery-consuming sensors (e.g., accelerometer) and low sampling rate (e.g., 10Hz). CPU usage is primarily dependent on data collection, while memory usage is related to the features and complexity of the ML algorithm. Finally, the generalization requirement is met in studies that consider user, location and position independency into account.

Capillaries are the smallest vessels in the body which are responsible for delivering oxygen and nutrients to surrounding cells. Various life-threatening diseases are known to alter the density of healthy capillaries and the flow velocity of erythrocytes within the capillaries. In previous studies, capillary density and flow velocity were manually assessed by trained specialists. However, manual analysis of a standard 20-s microvascular video requires 20 min on average and necessitates extensive training. Thus, manual analysis has been reported to hinder the application of microvascular microscopy in a clinical environment. To address this problem, this paper presents a fully automated state-of-the-art system to quantify skin nutritive capillary density and red blood cell velocity captured by handheld-based microscopy videos. The proposed method combines the speed of traditional computer vision algorithms with the accuracy of convolutional neural networks to enable clinical capillary analysis. The results show that the proposed system fully automates capillary detection with an accuracy exceeding that of trained analysts and measures several novel microvascular parameters that had eluded quantification thus far, namely, capillary hematocrit and intracapillary flow velocity heterogeneity. The proposed end-to-end system, named CapillaryNet, can detect capillaries at ~0.9 s per frame with ~93% accuracy. The system is currently used as a clinical research product in a larger e-health application to analyse capillary data captured from patients suffering from COVID-19, pancreatitis, and acute heart diseases. CapillaryNet narrows the gap between the analysis of microcirculation images in a clinical environment and state-of-the-art systems.

Automatic human activity detection, mainly transport-wise, is very relevant for architects and urban planners (among many others) when designing cities, roads, public transportation systems, etc. Such detection allows to better plan our cities and has been made possible with the widespread use of smartphones carrying several different sensors. We developed edgeTrans, a system based on a smartphone application (app, for short), a database, and a server. The database stores the trips that were done, the server runs a machine learning algorithm that generates a model (i.e., a classifier) which is then integrated into the edgeTrans app. This app, after being installed, when running in a smartphone indicates the transport mode that is being used without requiring a network connection; it can now be downloaded from the Android Play Store or from the iOS iTunes (the app is called Woorti). The results obtained in a real-world setting are very encouraging taking into account the requirements (e.g., accuracy, and low cost).

Latency sensitive services such as credit-card fraud detection and website targeted advertisement rely on Big Data platforms which run on top of memory managed runtimes, such as the Java Virtual Machine (JVM). These platforms, however, suffer from unpredictable and unacceptably high pause times due to inadequate memory management decisions (e.g., allocating objects with very different lifetimes next to each other, resulting in severe memory fragmentation). This leads to frequent and long application pause times, breaking Service Level Agreements (SLAs). This problem has been previously identified, and results show that current memory management techniques are ill-suited for applications that hold in memory massive amounts of long-lived objects (which is the case for a wide spectrum of Big Data applications).

In a growing number of cities, cycling is being seriously considered to help solving traffic congestion, parking, etc. It is also a cleaner and healthier mean of urban transportation. However, changing users behavior (e.g., using a bicycle instead of a car) is not simple. Thus, to promote and motivate cycling we propose Biklio, a cycling rewarding system that, based on the use of a smartphone, detects when a user starts cycling and makes her/him eligible for rewards. This solution uses a smartphone application that includes a bicycle usage detection component. This component is both highly accurate and cheap, while respecting other requirements, and is based on the use of a Bluetooth Low Energy (BLE) sensor, installed on each bicycle, which is detected by smartphones. The system is implemented and running, and the results obtained are very encouraging.

The cloud is an increasingly popular platform to deploy applications as it lets cloud users to provide resources to their applications as needed. Furthermore, cloud providers are now starting to offer a "pay-as-you-use" model in which users are only charged for the resources that are really used instead of paying for a statically sized instance. This new model allows cloud users to save money, and cloud providers to better utilize their hardware.

Big Data applications suffer from unpredictable and unacceptably high pause times due to Garbage Collection (GC). This is the case in latency-sensitive applications such as on-line credit-card fraud detection, graph-based computing for analysis on social networks, etc. Such pauses compromise latency requirements of the whole application stack and result from applications' aggressive buffering/caching of data, exposing an ill-suited GC design, which assumes that most objects will die young and does not consider that applications hold large amounts of middle-lived data in memory.

Big Data applications suffer from unpredictable and unacceptably high pause times due to bad memory management (Garbage Collection, GC) decisions. This is a problem for all applications but it is even more important for applications with low pause time requirements such as credit-card fraud detection or targeted website advertisement systems, which can easily fail to comply with Service Level Agreements due to long GC cycles (during which the application is stopped). This problem has been previously identified and is related to Big Data applications keeping in memory (for a long period of time, from the GC's perspective) massive amounts of data objects.

In certain restrictive usage scenarios, personal mobile devices are required to operate in some constrained manner. Security concerns tend to be the most typical motivation, for example, as in "Bring Your Own Device" use cases. However, because most device configurations are strictly controlled by their respective users, today it is practically infeasible to satisfy such requirements. In this paper, we present TrUbi, a system that allows for dynamic and temporary restriction of Android devices by disabling or locking specific functions for limited amounts of time, e.g. network blocked. TrUbi enforces global security policies by implementing an OS primitive named trust lease. Our TrUbi prototype can efficiently enforce security policies in unmodified real-world apps and paves the way for new apps that are currently unsupported by existing mobile platforms.

In this paper we propose a task based load distribution framework for Massively Multiplayer Online Games running in hybrid cloud environments. Our solution breaks down high level tasks into subtasks in such a way that i) core subtasks (those with strong timing constraints) are executed at private resources owned by game operators; while ii) background subtasks (those with looser timing/reliability constraints) can be offloaded to temporary resources acquired from a public cloud. Our approach is lightweight and allows for faster deployment of newly acquired servers, making it more suitable for temporary overload situations. We present evaluation results confirming our solution as a viable alternative to traditional strategies.

Graph data stores are a popular choice for a number of applications: social networks, recommendation systems, authorization and control access, and more. Such data stores typically support both distribution and replication of vertexes across physical nodes.

A new era of High-Performance Computing has been coming about during the last decade. The overabundance of resources lying idle throughout the Internet, for long periods of time, calls for resource-sharing infrastructures operating in the settings of the Cluster, Grid, P2P and Cloud. Many organizations own grids, frequently underutilized, but impose several restrictions to their usage by outside users. Despite the already extensive study in the field of Grid and Cloud computing, no solution was ever successful in reaching out to typical home users and their resource-intensive commodity applications. This is especially lacking in an open environment with no cost and low access barriers (e.g. authentication, configuration). We propose C|$^3$|P, a comprehensive distributed cycle-sharing framework for enabling the sharing of computational resources in a decentralized and free computing cloud platform, across large-scale networks and thus improve the performance of commonly used applications. C|$^3$|P encompasses the following activities: application adaptation, job scheduling, resource discovery, reliability of job results and overlay network management. C|$^3$|P evaluation shows that any ordinary Internet user is able to easily and effectively take advantage of remote resources, namely CPU cycles, for their own benefit; or provide spare cycles to other users, getting incentives in return, in a free, yet fair and managed global infrastructure.

Traditionally, commercial MMOGs are deployed on large privately owned server clusters with hundreds of computing devices linked through high bandwidth connections. In this scenario, the dynamic and unpredictable workload variability of MMOGs frequently leads to resources being under/over used with negative impact on playability and/or cost-effectiveness. In our research work, we see cloud computing as a fundamental approach to mitigate the problem of inefficient resource provisioning, due to its inherent elasticity properties. Thus, we propose a cloud-aware middleware for MMOGs, in which virtual machines obtained from cloud providers are added and removed from the system according to load changes observed at runtime. In this paper, we report on our first steps towards such an infrastructure.

Cooperative editing applications enable geographically distributed users to concurrently edit a shared document space over a computer network. These applications present several technical challenges related to the scalability of the system and the promptness with which relevant updates are disseminated to the concerned users. This paper presents Cooperative Semantic Locality Awareness (CoopSLA), a consistency model for cooperative editing applications that is scalable and efficient with regards to user needs. In CoopSLA, updates to different parts of the document have different priorities, depending on the relative interest of the user in the region in which the update is performed; updates that are considered relevant are sent to the user promptly, while less important updates are postponed. As a result, the system makes a more intelligent usage of the network resources, since (1) it saves bandwidth by merging postponed updates and (2) it issues fewer accesses to the network resources as a result of both update merging and message aggregation. We have implemented a collaborative version of the open source Tex editor TexMaker using the CoopSLA approach. We present evaluation results that support our claim that CoopSLA is very effective regarding network usage while fulfilling user needs (e.g. ensuring that relevant updates are disseminated in time).

Context-aware systems take into account the user's current context (such as location, time and activity) to enrich the user interaction with the application. However, these systems may produce huge amounts of information that must be efficiently propagated to a group of people or even large communities while still protecting the privacy of the participants.

The continued rise in Internet users and the ever-greater complexity of Web content degrade user-perceived latency in the Web. Web caching, prefetching and data deduplication are techniques that are used to try to mitigate this effect. Regardless of the amount of bandwidth available for network traffic, Web prefetching has the potential to consume free bandwidth to its limits. Deduplication explores data redundancies to reduce the amount of data transferred through the network, thereby freeing occupied bandwidth. To the best of our knowledge no previous work has been done which applies these two techniques combined to Web traffic. The motivation of this work is to ask if, by combining these two techniques, it is possible to significantly reduce the amount of bytes transmitted per user request, thereby improving the user-perceived latency in the Web. In the present work, we developed and implemented a system that combines the use of Web prefetching and deduplication techniques. By testing our system using real-world user navigation traces, we show that deduplication is able to substantially reduce the network costs of prefetching (up to 34% savings in transferred bytes), without degrading the latency gains due to prefetching. By adjusting deduplication parameters it is possible to improve the latency relative to when using only prefetching.

Multi-user chat (MUC) applications raise serious challenges to developers concerning scalability and efficient use of network bandwidth, due to a large number of users exchanging lots of messages in real-time. We propose a new approach to MUC message propagation based on an adaptable consistency model bounded by three metrics: Filter, Time and Volume. In this model, the server propagates some messages as soon as possible while others are postponed until certain conditions are met, according to each client consistency requirements. These requirements can change during the session lifetime, constantly adapting to each client's current context.

Ubiquitous environments still suffer from low availability given that any device may fail and it is hard to replace a failed element. In this paper we present AdaptUbiFlow (Adaptive Ubiquitous Workflow), an OpenCOPI´s element that aims to increase the availability of an ubiquitous system. When a device fails, AdaptUbiFlow supports the automatic reconfiguration of the system replacing the failed device (or service) by an equivalent one, this makes the system fault-tolerant without the need of any manual intervention. The replacing of a device/service is chosen taking into account not only the QoS and QoC (Quality of Context) provided but also the application's execution flow to ensure that the best adaptation option will be chosen. AdaptUbiFlow evaluation showed encouraging results.

The Internet has witnessed a steady and widespread increase in available idle computing cycles and computing resources in general. Such available cycles simultaneously allow and foster the increase in development of existing and new computationally demanding applications, driven by algorithm complexity, intensive data processing, or both. Available cycles may be harvested from several scenarios, ranging from college or office LANs, cluster, grid and utility or cloud computing infrastructures, to peer-to-peer overlay networks. Existing resource discovery protocols have a number of shortcomings for the existing variety of cycle sharing scenarios. They either (i) were designed to return only a binary answer stating whether a remote computer fulfills the requirements, (ii) rely on centralized schedulers (or coherently replicated) that are impractical in certain environments such as peer-to-peer computing, (iii) they are not extensible as it is impossible to define new resources to be discovered and evaluated or new ways to evaluate them. In this paper we present a novel, extensible, expressive, and flexible requirement specification algebra and resource discovery middleware. Besides standard resources (CPU, memory, network bandwidth,...), application developers may define new resource requirements and new ways to evaluate them. Application programmers can write complex requirements (that evaluate several resources) using fuzzy logic operators. Each resource evaluation (either standard or specially coded) returns a value between 0.0 and 1.0 stating the capacity to (partially) fulfill the requirement, considering client-specific utility depreciation (i.e., partial-utility, a downgraded measure of how the user assesses the available resources) and policies for combined utility evaluation. By comparing the values obtained from the various hosts, it is possible to precisely know which ones best fulfill each client's needs, regarding a set of required resources.

Exploiting the emerging reality of affordable multi-core architectures goes through providing programmers with simple abstractions that would enable them to easily turn their sequential programs into concurrent ones that expose as much parallelism as possible. While transactional memory promises to make concurrent programming easy to a wide programmer community, current implementations either disallow nested transactions to run in parallel or do not scale to arbitrary parallel nesting depths. This is an important obstacle to the central goal of transactional memory, as programmers can only start parallel threads in restricted parts of their code.

Topological worms, such as those that propagate by following links in an overlay network, have the potential to spread faster than traditional random scanning worms because they have knowledge of a subset of the overlay nodes, and choose these nodes to propagate themselves; and also because they can avoid traditional detection mechanisms. Furthermore, this worm propagation strategy is likely to become prevalent as the deployment of networks with a sparse address space, such as IPv6, makes the traditional random scanning strategy futile. We present a novel approach for containing topological worms based on the fact that some overlay nodes may not have common vulnerabilities, due to their platform diversity. By reorganizing the overlay graph, it is possible to contain topological worms in small islands of nodes with common vulnerabilities that only have knowledge of themselves or nodes running on distinct platforms. We also present the design of Verme, a peer-to-peer overlay based on Chord that follows this approach, and VerDi, a DHT layer built on top of the Verme routing overlay. Simulations show that Verme and VerDi have a low overhead when compared to Chord's corresponding layers, and that our new overlay design helps containing, or at least slowing down the propagation of topological worms.

Peer-to-peer overlays envision a single overlay substrate that can be used (possibly simultaneously) by many applications, but current overlays either target fast, few-hop lookups for contacting directly the responsible nodes, or slower multi-hop lookups that can be used by applications that exploit the overlay topology (like multicast or anycast). In this paper we present Pastel, an extension to Pastry that bridges the gap between the two types of overlays. Pastel maintains both Pastry routing tables and a full information table, and we show how we can exploit synergies between the maintenance of the two. We also propose a novel API that is richer than the one offered by existing overlays, to give applications control over the type of lookups (structured, multi-hop routing, or attempt direct contact). We implemented Pastel in a discrete-event packet level simulator and our results show that Pastel has lookups that are usually more efficient than Pastry's. Furthermore, the bandwidth required by Pastel is modest, even for a system with thousands of nodes.

There have been a few proposals aiming at bridging the gap between institutional grid infrastructures (e.g., Globus-based), popular cycle-sharing applications (e.g., SETIQhome), and massively used decentralized P2P file-sharing applications. Nonetheless, no such infrastructure was ever successful in allowing, in a large-scale, home users to run popular desktop applications faster, by using spare cycles in other users' machines and, in return, donate their spare cycles to run other users' applications. We present a novel application and programming model that was designed to overcome some of the barriers to the deployment of a generic peer-to-peer grid infrastructure. In particular, we want to enable a trivial deployment in such infrastructures of existing applications that are in widespread use but do not currently exploit parallelism for improved performance. The model presented in this paper revolves around the concept of a Gridlet, a semantics-aware unit of workload division and computation off-load. A gridlet is a chunk of data associated with the operations to be performed on the data, and in many cases these operations consist of unmodified application binaries. Moreover, the concept of gridlet is also employed for resource management, and accounting of peer contribution. We believe this new concept, absent in other proposals, will significantly lower the barriers for exploiting parallel execution in popular applications, thus improving the chances of the gridlet model being widely adopted.

Mobile collaborative environments, being naturally loosely-coupled, call for optimistic replication solutions in order to attain the requirement of decentralized highly available access to data. However, such connectivity assumptions are also a decisive hindrance to the ability of optimistic replication protocols to rapidly guarantee consistency among the set of loosely-coupled replicas. This paper proposes the extension of conventional optimistic replication protocols to exploit the presence of extraneous nodes surrounding the group of replica nodes in an increasingly ubiquitous computational universe. In particular, we show that using such extra nodes as temporary carriers of lightweight consistency meta-data may significantly improve the efficiency of a replicated system; notably, it reduces commitment delay and conflicts, and allows more network-efficient propagation of updates. We support such a statement with experimental results obtained from a simulated environment.

Abstract Mobile and other loosely coupled environments call for decentralized optimistic replication protocols that provide highly available access to shared objects, while ensuring eventual consistency. We propose a protocol based on epidemic weighted voting for achieving such a goal with better availability than traditional primary commit approaches. We improve previous epidemic weighted voting solutions by allowing commitment of multiple, happened‐before related updates at a single distributed election round. We demonstrate that our protocol, in contrast to basic weighted voting solutions, achieves similar update commitment ratios to the primary commit alternative. The improvement over basic weighted voting is especially amplified with weaker replica connectivity, as in mobile and other loosely coupled environments. We support such claims by presenting comparison performance results obtained from side‐by‐side execution of reference protocols in a simulated environment. Copyright © 2007 John Wiley & Sons, Ltd.

The arising of grid platforms introduced inexpensive and highly available computing, storage and networking resources. Therefore, in a worldwide trend, institutions aggregate on virtual organizations, registering their resources to the grid and in return accessing a virtually limitless warehouse. This overabundance allowed the emergence of innovative application and business models, delivering the solution to several large-scale problems, as is the case of data processing, storage and sharing in CERN's Large Hadron Collider Project. In order to allow system administrators to assure resources are employed in a coordinated and secure way, policy mechanisms need to cope with such new models and the increased complexity in resource usage management. However, current grid platforms only provide simple primitives in their authorization modules. By restricting access control mechanisms to ACLs and role-based models, they disregard powerful usage semantics, such as those which are history-based (e.g. the Chinese-wall security policy). This absence obliges the development of ad hoc security managers for each deployed resource, introducing vulnerabilities in the security architecture. The use of advanced policies, and more specifically history-based policies, provides a natural method for expressing and enforcing several grid usage patterns, such as fair resource consumption. Additionally, some policy concepts not usually found in policy engines, such as periodic reevaluation, assure an effective policy enforcement. We present the Heimdhal system, a history-enabled policy engine which allows the definition, enforcement and accounting of history-based policies in grid platforms, and more specifically in Globus Toolkit 4.0. A practical evaluation using selected usage patterns corroborates the effectiveness of this kind of policies in grid computing environments, denoting encouraging performance results.

Advances in technology enabled new types of networks to appear (e.g. PDA based spontaneous networks). Here, execution of transactions manipulating distributed objects is affected by the intermittent connectivity thereby causing unnecessary aborts. This paper presents a solution to make transactions resilient to intermittent connections thus increasing transaction throughput. This is achieved by i) allowing transactions to further span in time and/or ii) relaxing the consistency properties of transactions. For this purpose, application programmers specify the minimum transaction requirements (which depend on the application semantics) using policies. Evaluation shows that slightly increasing the maximum transaction execution time and/or reducing consistency, transaction throughput increases substantially. This solution is implemented in MobileTrans-a distributed object-oriented middleware system providing adaptive transactions aiding the reliable management of distributed object graphs. Policies are specifically designed to overcome the connectivity intermittence problem. The minimum transaction requirements are specified as parameters to these policies without having to change application code.

Content-based indexing [MCM01] is a technique of proven effectiveness for efficient transference of file contents over low bandwidth network links. Departing from this context, the natural step of extending the application of this technique to local file storage has been proposed by a number of storage solutions [CN02, QD02, BF04]. To some extent, all these solutions share a core storage model. File contents are divided into disjoint chunks of data, each of which is individually stored, along with a unique hash of its contents, in a repository of chunks. The actual files are then stored as sequences of possibly shared references to chunks in the repository.

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 inumerous 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).

The need for sharing is well known in a large number of distributed collaborative applications. These applications are difficult to develop for wide area (possibly mobile) networks because of slow and unreliable connections. For this purpose, we developed a platform called OBIWAN that: i) allows the application to decide, in run-time, the mechanism by which objects should be invoked, remote method invocation or invocation on a local replica, ii) allows incremental replication of large object graphs, iii) allows the creation of dynamic clusters of data, and iv) provides hooks for the application programmer to implement a set of application specific properties such as relaxed transactional support or updates dissemination. These mechanisms allow an application to deal with situations that frequently occur in a (mobile) wide-area network, such as disconnections and slow links: i) as long as objects needed by an application (or by an agent) are colocated, there is no need to be connected to the network, and ii) it is possible to replace, in run-time, remote by local invocations on replicas, thus improving the performance and adaptability of applications. The prototype is developed in Java, is very small and simple to use, the performance results are very encouraging, and existing applications can be easily modified to take advantage of OBIWAN.

We consider a shared store based on distributed shared memory (DSM) supporting persistence by reachability (PBR) a very simple data sharing model for a distributed system. This DSM+PBR model is based on distributed garbage collection (GC). Within a general model for DSM+PBR, we specify a distributed GC algorithm that is efficient and scalable. Its main features are: (i) independent collection of memory subsets (even when replicated), (ii) orthogonal from coherence, (iii) asynchrony, and (iv) a simple heuristic to collect cycles avoiding extra I/O costs. We briefly describe our implementation and show some performance results.