Model-based reinforcement learning (RL) offers a solution to the data inefficiency that plagues most model-free RL algorithms. However, learning a robust world model often requires complex and deep architectures, which are computationally expensive and challenging to train. Within the world model, sequence models play a critical role in accurate predictions, and various architectures have been explored, each with its own challenges. Currently, recurrent neural network (RNN)-based world models struggle with vanishing gradients and capturing long-term dependencies. Transformers, on the other hand, suffer from the quadratic memory and computational complexity of self-attention mechanisms, scaling as $O(n^2)$, where $n$ is the sequence length. To address these challenges, we propose a state space model (SSM)-based world model, Drama, specifically leveraging Mamba, that achieves $O(n)$ memory and computational complexity while effectively capturing long-term dependencies and enabling efficient training with longer sequences. We also introduce a novel sampling method to mitigate the suboptimality caused by an incorrect world model in the early training stages. Combining these techniques, Drama achieves a normalised score on the Atari100k benchmark that is competitive with other state-of-the-art (SOTA) model-based RL algorithms, using only a 7 million-parameter world model. Drama is accessible and trainable on off-the-shelf hardware, such as a standard laptop. Our code is available at https://github.com/realwenlongwang/Drama.git.

Dynamic scheduling of access to shared resources by autonomous systems is a challenging problem, characterized as being NP-hard. The complexity of this task leads to a combinatorial explosion of possibilities in highly dynamic systems where arriving requests must be continuously scheduled subject to strong safety and time constraints. An example of such a system is an unsignalized intersection, where automated vehicles’ access to potential conflict zones must be dynamically scheduled. In this paper, we apply Neural Monte Carlo Tree Search (NMCTS) to the challenging task of scheduling platoons of vehicles crossing unsignalized intersections. Crucially, we introduce a transformation model that maps successive sequences of potentially conflicting road-space reservation requests from platoons of vehicles into a series of board-game-like problems and use NMCTS to search for solutions representing optimal road-space allocation schedules in the context of past allocations. To optimize search, we incorporate a prioritized re-sampling method with parallel NMCTS (PNMCTS) to improve the quality of training data. To optimize training, a curriculum learning strategy is used to train the agent to schedule progressively more complex boards culminating in overlapping boards that represent busy intersections. In a busy single four-way unsignalized intersection simulation, PNMCTS solved 95% of unseen scenarios, reducing crossing time by 43% in light and 52% in heavy traffic versus first-in, first-out control. In a 3x3 multi-intersection network, the proposed method maintained free-flow in light traffic when all intersections are under control of PNMCTS and outperformed state-of-the-art RL-based traffic-light controllers in average travel time by 74.5% and total throughput by 16% in heavy traffic.

Leveraging the coordination potential of connected and automated vehicles (CAVs), we introduce a new algorithm for efficient slot-based motorway on-ramp merging control. The algorithm provides a low-delay and high-throughput solution for merging by allowing on-ramp vehicles to target the earliest available slot on the motorway and eventually join it without any unnecessary interference (e.g., by a traffic light, preceding on-ramp vehicles, or motorway traffic). Since the vehicles on the ramp only target available slots, the vehicles travelling on the motorway (also in slots) do not need to change their trajectories to avoid collisions at the merging point resulting in no motorway capacity drop. The algorithm uses multi-segment constant-acceleration linear motion to solve the velocity harmonization issue arising during the merging process, allowing on-ramp CAVs to precisely follow the planned speed profile and join their target slots. Simulation results show that the proposed approach linearly increases motorway slot usage with increasing on-ramp traffic volume. Compared to two state-of-the-art methods, the proposed approach is 58% and 39% faster with respect to speed convergence respectively.

Abstract The deployment of virtual network functions (VNFs) at edge servers potentially impairs the performance of latency-sensitive applications due to their computational cost. This work considers a new approach to addressing this problem that provides line rate acceleration of VNFs by employing field-programmable gate array (FPGA) equipped edge servers. This approach has been validated by practical use cases with both TCP and UDP as underlying protocol on a physical testbed environment. We examine the performance implications of executing a security VNF at an FPGA-equipped edge server. We experimentally demonstrate reduced VNF execution latency and energy consumption for a real-time video streaming application in comparison with a software-only baseline. In particular, the results show that the approach lowers VNF execution latency and power consumption at the edge by up to 44% and 76%, respectively, in our experiments while satisfying time constraints and maintaining confidentiality with high scalability. We also highlight the potential research challenges to make this approach viable in practice.

Mobile Crowd Sensing (MCS) is an emerging paradigm that exploits the ubiquity of smartphones and cheap sensor devices to collect data and thus contribute to the provision of useful services, especially in the domains of urban life. While many MCS implementations have been proposed for different applications, the lack of common performance metrics means that their efficiency cannot be easily compared. In this paper, we formalize a generic coverage model for the class of MCS systems sampling spatial phenomena before introducing a way to produce one such a metric by exploiting a spatio-temporal estimator. We avail of a large-scale dataset of users' mobility traces to demonstrate the use of the newly introduced metric in informing the resolution of a typical problem in MCS system design.

Small scale electrical demand forecasting is an emerging field motivated by the penetration of renewable energy sources and the growth of microgrids and virtual power plants. These advances pose more complex forecasting challenges compared to the already established large scale forecasting approaches. Current short term load forecasting methods deal with two types of day, normal and anomalous, which are predicted separately. Anomalous days are classified as such ahead of time, based on key calendar events such as public holidays. However, there are some anomalous days which are not always predictable on a day ahead basis. Due to unforeseen events, a seemingly normal day can progress towards an anomalous case causing high errors in prediction. We propose a new dynamic forecasting mechanism that actively monitors residential electrical demand along a forecasted day, and detects anomalous pattern changes from a previously predicted demand of the day. A self-organising map is employed to detect anomalous days as they progress. Once an anomaly is detected, a neural network based prediction system changes its input neurons according to a previously detected and recorded match found in a database of anomalous days, in order to accommodate the anomalous day prediction. Results are based on measured power demands recorded in Ireland from domestic smart-meters between 2009-2011, and focus on small scale residential electrical demands of up to 350 kWh. During anomalous days our dynamic prediction approach achieves forecasting results within 3.63% of the real load, down from the 7.37% obtained by the initial prediction algorithm and the 5.41% achieved by standalone re-prediction, without pattern matching.

Large-scale, multi-agent systems are too complex for optimal control strategies to be known at design time and as a result good strategies must be learned at runtime. Learning in such systems, particularly those with multiple objectives, takes a considerable amount of time because of the size of the environment and dependencies between goals. Transfer Learning (TL) has been shown to reduce learning time in single-agent, single-objective applications. It is the process of sharing knowledge between two learning tasks called the source and target. The source is required to have been completed prior to the target task. This work proposes extending TL to multi-agent, multi-objective applications. To achieve this, an on-line version of TL called Parallel Transfer Learning (PTL) is presented. The issues involved in extending this algorithm to a multi-objective form are discussed. The effectiveness of this approach is evaluated in a smart grid scenario. When using PTL in this scenario learning is significantly accelerated. PTL achieves comparable performance to the base line in one third of the time.

For most safety-related applications that are envisaged in VANETs, the provisioning of a real-time medium access control is of great importance. However, the ability to access the wireless medium in a collision-free and time-bounded manner is particularly challenging in networks with unreliable wireless channel and dynamic topologies. Existing CSMA protocols such as 802.11p are prone to high rates of transmission collision, whereas TDMA-based protocols are not able to cope with the highly dynamic nature of vehicular networks. In this paper, we propose a novel MAC protocol: Real-time Reservation Protocol (RRP) which supports reliable and timely broadcast in VANETs. We believe that the vision of context awareness and farsightedness which constitute the core of most safety applications in VANETs should be brought to the design of the MAC layer as well. In the proposed protocol, broadcast messages are transmitted with high success rates, and the maximum time to access the medium is bounded. In a simulation-based study we compare the performance of RRP with 802.11p and RR-ALOHA in terms of packet delivery rate and staleness - a novel application-level QoS metric. Results indicate that RRP achieved satisfactory performance, which demonstrates the feasibility and effectiveness of real-time medium access control in VANETs.

This article describes Distributed W-Learning (DWL), a reinforcement learning-based algorithm for collaborative agent-based optimization of pervasive systems. DWL supports optimization towards multiple heterogeneous policies and addresses the challenges arising from the heterogeneity of the agents that are charged with implementing them. DWL learns and exploits the dependencies between agents and between policies to improve overall system performance. Instead of always executing the locally-best action, agents learn how their actions affect their immediate neighbors and execute actions suggested by neighboring agents if their importance exceeds the local action's importance when scaled using a predefined or learned collaboration coefficient. We have evaluated DWL in a simulation of an Urban Traffic Control (UTC) system, a canonical example of the large-scale pervasive systems that we are addressing. We show that DWL outperforms widely deployed fixed-time and simple adaptive UTC controllers under a variety of traffic loads and patterns. Our results also confirm that enabling collaboration between agents is beneficial as is the ability for agents to learn the degree to which it is appropriate for them to collaborate. These results suggest that DWL is a suitable basis for optimization in other large-scale systems with similar characteristics.

Wireless sensor networks (WSNs) have attracted growing interest in the last decade as an infrastructure to support a diversity of ubiquitous computing and cyber-physical systems. However, most research work has focused on protocols or on specific applications. As a result, there remains a clear lack of effective, feasible and usable system architectures that address both functional and non-functional requirements in an integrated fashion. In this paper, we outline the EMMON system architecture for large-scale, dense, real-time embedded monitoring. EMMON provides a hierarchical communication architecture together with integrated middleware and command and control software. It has been designed to use standard commercially-available technologies, while maintaining as much flexibility as possible to meet specific applications requirements. The EMMON architecture has been validated through extensive simulation and experimental evaluation, including a 300+ node test-bed, which is, to the best of our knowledge, the largest single-site WSN test-bed in Europe to date.

Vehicular networks enable the development of driver assistance and automated driving applications that need to coordinate the behaviour of multiple vehicles. Safe coordination requires a level of communication reliability, determinism and timeliness that current systems do not offer. In particular, the challenge of reliably establishing membership in vehicular group communication systems has only partly been addressed. In this context, a group is often defined as the set of vehicles that are present in a given area. Existing membership protocols allow false negatives to occur - vehicles that are in the area may not be seen as members. Applications that use these protocols may critically be unaware of some nearby vehicles. We introduce a novel membership protocol that eliminates false negatives by integrating communication as a reliable means of detecting the physical presence of a vehicle, with (distance) sensing as a reliable means of detecting the absence of other vehicles. We compare an implementation of the membership protocol against a more traditional protocol in terms of error rate and overhead. We show our protocol delivers stronger guarantees with lower overhead, at the cost of requiring more sophisticated sensors.

This paper presents a model-driven approach to developing pervasive computing applications that exploits design time information to support the engineering of planning and optimisation algorithms that reflect the presence of uncertainty, dynamism and complexity in the application domain. In particular the task of generating code to implement planning and optimisation algorithms in pervasive computing domains is addressed. We present a layered domain model containing a set of object oriented specifications for modelling physical and sensor/actuator infrastructure and state-space information. Our model-driven engineering approach is implemented in two transformation algorithms. The initial transformation parses the domain model and generates a planning model for the application being developed that encodes an application's states, actions and rewards. The second transformation parses the planning model and selects and seeds a planning or optimisation algorithm for use in the application. We present an empirical evaluation of the impact of our approach on the development effort associated with a pervasive computing application from the Intelligent Transportation Systems (ITS) domain, and provide a quantitative evaluation of the performance of the algorithms generated by the transformations.

Access to shared resources can be controlled by schedules or mutual exclusion. Such methods are not practical in an environment with dynamic participants, where nodes requiring access to shared resources can enter or leave the scene at any time. Current scheduling methods are usually centralized, demand that the system has a clear idea of when the resources are required and do not consider communication failures. Current implementations of distributed mutual exclusion use token- or permission-based methods. Dynamic participation amplifies the lost token problem in token-based approaches, while limited knowledge of the number of nodes makes obtaining quora and consensus in permission-based approaches impossible, rendering both mutual exclusion implementations impractical. This paper presents the CwoRIS protocol which enables short-term scheduling in real-time within an environment with dynamic participants. It motivates the need to support dynamic participants by means of a scenario for autonomous vehicle coordination in intersection crossing. The paper shows that the protocol is able to work in an environment with message loss and argues its correctness by showing mutual exclusion: there are no cases in which two nodes have access to the same resources at the same time.

Wireless sensor networks necessitate a programming model different from those used to develop desktop applications. Typically, resources in terms of power and memory are constrained. C is the most common programming language used to develop applications on very small embedded sensor devices. We claim that C does not provide efficient mechanisms to address the implicit asynchronous nature of sensor sampling. C applications for these devices suffer from a disruption in their control flow. In this paper, we present FlowTalk, a new object-oriented programming language aimed at making software development for wireless embedded sensor devices easier. FlowTalk is an object-oriented programming language in which dynamicity (e.g., object creation) has been traded for a reduction in memory consumption. The event model that traditionally comes from using sensors is adapted in FlowTalk with controlled disruption, a light-weight continuation mechanism. The essence of our model is to turn asynchronous long-latency operations into synchronous and blocking method calls. FlowTalk is built for TinyOS and can be used to develop applications that can fit in 4 KB of memory for a large number of wireless sensor devices.

Model-driven engineering addresses issues of platform heterogeneity and code quality through the use of high-level system models and subsequent automatic transformations. Adoption of the model-driven software engineering paradigm for embedded systems necessitates specification of appropriate models of often complex systems. Modern embedded systems are typically composed of multiple functional and nonfunctional concerns, with the nonfunctional concerns (e.g., timing and performance) typically affecting the design and implementation of the functional concerns. The presence of crosscutting concerns makes specification of adequate platform-independent models a significant challenge. Aspect-oriented software development is a separation of concerns technique that decomposes systems into distinct features with minimal overlap. In this article, we illustrate how Theme/UML, an aspect-oriented modeling approach, can be used to separate embedded systems concerns and reduce complexity in design. We also present Model-Driven Theme/UML, a toolset for model-driven engineering of embedded systems that supports modularised design with Theme/UML and automatic transformations to composed models and source code.

As mobile applications become more widespread, programming paradigms and middleware architectures designed to support their development are becoming increasingly important. The event-based programming paradigm is a strong candidate for the development of mobile applications due to its inherent support for the loose coupling between components required by mobile applications. However, existing middleware that supports the event-based programming paradigm is not well suited to supporting location-aware mobile applications in which highly mobile components come together dynamically to collaborate at some location. This paper presents a number of techniques including location-independent announcement and subscription coupled with location-dependent filtering and event delivery that can be used by event-based middleware to support such collaboration. We describe how these techniques have been implemented in STEAM, an event-based middleware with a fully decentralized architecture, which is particularly well suited to deployment in ad hoc network environments. The cost of such location-based event dissemination and the benefits of distributed event filtering are evaluated.

Pedestrian safety is a major concern in road transportation as pedestrian/vehicle accidents account for the second largest cause of traffic-related injuries and fatalities worldwide. Considerable work has examined the use of lidar, radar and computer vision for pedestrian detection but existing solutions are costly and work only if pedestrians are in the vehicle's line-of-sight. In this paper, we present a novel technique based on wireless sensor networks that is cheap and enables pedestrian detection beyond the driver's horizon. The detection system is based on the use of "cat's eyes" augmented with embedded processing and communication capabilities that are able to detect pedestrians and forward this information along the road. We describe how such a system was successfully built with SOL, a high-level programming language for wireless sensor networks. Initial results show that the system obtains detection rates of 100%, false positive rates of 0%, and that the precision of the estimated position of pedestrians depends on their heading and relative position to sensor nodes.

As the technology underlying sensor networks becomes more advanced and reliable, ubiquitous computing will come closer to being a reality. This paper details the design and deployment of several sensor nodes that use the delay tolerant network approach in order to meet the relevant application requirements. Two applications are presented, lake water quality monitoring in rural lakes and noise level logging in urban areas and along motorways. The installations are discussed and initial results presented.

This paper presents YABS, a novel domain-specific language for defining entity behavior in pervasive computing environments. The programming model of YABS is inspired by nature and, in particular, the observations made by the French biologist Grassé on how social insects coordinate their actions using indirect communication via the environment, a phenomenon that has become known as stigmergy. Following this approach yields a simple yet expressive language that abstracts the complexities of dealing with the variety of underlying technologies typical of pervasive computing environments and that facilitates the incremental construction and improvement of solutions while providing high-level constructs for defining the behavior of entities and their coordination. We show how YABS has been used to program a number of pervasive computing applications both deployed and simulated.

Mobile applications, for example mobile robots, are playing an increasingly important role in our everyday lives. Since components of these applications share their environment with each other and with humans, they need to coordinate their behavior to respect strong safety constraints. Unfortunately, they typically make use of wireless networks in which real-time communication is highly unreliable, making coordination particularly challenging. We present a real-time communication model for wireless networks that takes into account that communication might not be reliable. It provides feedback to mobile components about the state of communication, so that they can adapt their behavior accordingly. We show how this model can be used to build reliable mobile applications in wireless networks: this involves specifying the safety constraints that need to be respected, and translating them into constraints on the behavior of individual components. To illustrate our approach, we describe an example from the intelligent transportation systems domain

Context-aware applications rely on the ability to perceive the state of the surrounding environment. In this paper, we address a class of such applications where real-time guarantees are required on top of mobile ad hoc networks. While guaranteed timeliness is a critical requirement, the unpredictability of dynamic wireless networks adversely impacts such guarantees. Therefore, we identify the challenges and the requirements on different architectural levels in order to provide timeliness guarantees. None of the existing systems have succeeded in providing adequate solutions to all of the identified requirements. Therefore, we describe a cross-layer architecture that supports the development of real-time context-aware applications for wireless networks, in particular, ad hoc networks. This cross-layer architecture is based on three main components. (i) Sentient objects - mobile intelligent software agents that extract, interpret and use context information. (ii) Event-based real-time middleware supports communication between sentient objects and provides hard real-time guarantees within adaptable geographic spaces. (iii) A real-time routing and resource reservation protocol attempts to discover and maintain real-time constrained routes within these proximities in a multi-hop ad hoc network

With more and more computing devices being deployed in buildings there has been a steady rise in buildings' electricity consumption. At the same time there is a pressing need to reduce overall building energy consumption. Pervasive computing could further exacerbate this problem but it could also provide a solution. Context information (e.g., user location) likely to be available in pervasive computing environments could enable highly effective device power management. The objective of such context-aware power management (CAPM) is to minimise the overall electricity consumption of a building while maintaining acceptable user-perceived device performance. To investigate the potential of CAPM we conducted experimental trials for two simple location-aware power management policies. Our results highlight the presence of two distinct user behaviour patterns but also show that location alone is not enough for effective power management. We therefore propose a CAPM framework that employs Bayesian networks to support prediction of user behaviour patterns from multi-modal sensor data for effective power management. We further propose the use of acoustic data as an interesting context for predicting finer-grained user behaviour. The paper presents an initial evaluation of the resulting framework.

Event-based middleware is currently being applied for application component integration in a range of application domains. As a result, a variety of event services has been proposed to address different requirements. In order to aid the understanding of the relationships between these systems, this paper presents a taxonomy of distributed event-based programming systems. The taxonomy is structured as a hierarchy of the properties of a distributed event system and may be used as a framework to describe such a system according to its properties. The taxonomy identifies a set of fundamental properties of event systems and categorizes them according to the event model supported and the structure of the event service. Event services are further classified according to their organization and their interaction models, as well as other functional and non-functional features.

Designers face many system optimization problems when building distributed systems. Traditionally, designers have relied on optimization techniques that require either prior knowledge or centrally managed runtime knowledge of the system's environment, but such techniques are not viable in dynamic networks where topology, resource, and node availability are subject to frequent and unpredictable change. To address this problem, we propose collaborative reinforcement learning (CRL) as a technique that enables groups of reinforcement learning agents to solve system optimization problems online in dynamic, decentralized networks. We evaluate an implementation of CRL in a routing protocol for mobile ad hoc networks, called SAMPLE. Simulation results show how feedback in the selection of links by routing agents enables SAMPLE to adapt and optimize its routing behavior to varying network conditions and properties, resulting in optimization of network throughput. In the experiments, SAMPLE displays emergent properties such as traffic flows that exploit stable routes and reroute around areas of wireless interference or congestion. SAMPLE is an example of a complex adaptive distributed system.

The emergence of truly ubiquitous computing, enabled by the availability of mobile, heterogenous devices that supply context information, is currently hampered by the lack of programming support for the design and development of context-aware applications. We have developed a framework which significantly eases the development of mobile, context-aware applications. The framework allows developers to fuse data from disparate sensors, represent application context, and reason efficiently about context, without the need to write complex code. An event based communication paradigm designed specifically for ad-hoc wireless environments is incorporated, which supports loose coupling between sensors, actuators and application components.

The term aspect-oriented programming (AOP) has come to describe\nthe set of programming mechanisms developed specifically to\nexpress crosscutting concerns. Since crosscutting concerns cannot\nbe properly modularized within object-oriented programming, they\nare expressed as aspects and are composed, or woven, with\ntraditionally encapsulated functionality referred to as components.\nMany AOP models exist, but their implementations are typically\ncoupled with a single language. To allow weaving of existing\ncomponents with aspects written in the language of choice, AOP\nrequires a language-independent tool.\nThis paper presents Weave.NET, a load-time weaver that allows\naspects and components to be written in a variety of languages and\nfreely intermixed. Weave.NET relies on XML to specify aspect\nbindings and standardized Common Language Infrastructure to\navoid coupling aspects or components with a particular language.\nBy demonstrating language-independence, Weave.NET provides a\nmigration path to the AOP paradigm by preserving existing\ndeveloper knowledge, tools, and software components. The tool?s\ncapabilities are demonstrated with logging aspects written in and\napplied to Visual Basic and C# components.

This paper describes an architecture that provides support for quality of service (QoS) specification and enforcement in heterogeneous distributed computing systems. The Quartz QoS architecture has been designed to overcome various limitations of previous QoS architectures that have constrained their use in heterogeneous systems. These limitations include dependencies on specific platforms and the fact that their functionality is often limited by design to one particular area of application. Quartz is able to accommodate differences among diverse computing platforms and areas of application by adopting a flexible and extensible platform-independent design, which allows its internal components to be rearranged dynamically in order to adapt the architecture to the surrounding environment. Further significant problems found in other QoS architectures, such as the lack of flexibility and expressiveness in the specification of QoS requirements and limited support for resource adaptation, are also addressed by Quartz. This paper describes the motivations for and design of Quartz in detail, presents a prototype implementation of Quartz and an analysis of its design based on experience with a number of applications that use this prototype.

Distributed application programmers rely on middleware such as CORBA in order to handle the complexity that arises from the distributed and heterogeneous nature of the underlying computing platform. CORBA, in particular, provides a media streaming mechanism that can be used both for media streaming and for associating QoS requirements with media streams. Despite defining the interfaces of the media streaming mechanism, the corresponding specification does not prescribe how QoS is enforced at low levels by the middleware. This paper describes the design and implementation of a QoS architecture, called Quartz, which has been integrated with CORBA in order to provide a framework that allows applications to transfer real-time media in open systems. This framework is employed to model and simulate a pattern recognition mechanism for use in an automated manufacturing cell, which is also described and analysed in this paper.

CORBA, the Common Object Request Broker Architecture, defines a framework for developing object-oriented distributed applications.Unfortunately, current implementations of CORBA have not been designed with support for mobile computers in mind.Using CORBA in a mobile environment raises a number of problems due to hardware mobility and the characteristics of wireless networks.This paper identifies and discusses these problems and presents the design and implementation of our Architecture for Location Independent CORBA Environments (ALICE).ALICE allows CORBA objects running on mobile devices to interact transparently with objects hosted by off-the-shelf CORBA implementations.Importantly, ALICE allows server as well as client objects to reside on mobile hosts without relying on a centralised location register to keep track of their whereabouts.1 introduction CORBA, the Common Object Request Broker Architecture [7], from the Object Management Group (OMG), defines a framework for developing object-oriented distributed applications.CORBA is based on the clientserver paradigm and the most important component in the architecture is the Object Request Broker (ORB) which is responsible for relaying object invocations from clients to server objects.Initially, the CORBA standard made no provision for interoperability between ORBS supplied by different vendors.Later versions of the standard addressed this issue by defining a standard protocol for inter-ORB communication which is known as the General Inter-ORB Protocol (GIOP) [7, Chapter 131 and which can PeMkion to make digital or hard copies of all or part of this work t'or PCrSOnal Or ChirOOnl use is granted without fee provided that comicare not made or distributed for profit or commercial advarltage and that copies bear this notice and the f'ull citation on the first page.ho copy otheRvise, to republish, to post on servers or to redistribute to lists.rcquircs prior specific permission and/or a fee.

Comprehensive distributed garbage collection in object-oriented distributed systems has mostly been addressed via distributed versions of graph-tracing algorithms, a legacy of centralised garbage collection techniques. Two features jeopardise the scalability of these approaches: the bottleneck associated with having to reach a global consensus before any resource can actually be reclaimed; and the overhead of eager log-keeping. This paper describes an alternative approach to comprehensive distributed garbage collection that entails computing the vector-time characterising the causal history of some relevant events of the mutator processes computations. Knowing the causal histories of these events makes it possible to identify garbage objects that are not identifiable by means of per-site garbage collection alone. Computing the vector-times necessary to identify garbage is possible without the unbounded space overheads usually associated with dynamically reconstructing vector-times of arbitrary events of distributed computations. Our approach integrates a lazy log-keeping mechanism and therefore tackles both of the aforementioned stumbling blocks of distributed garbage collection.

As use of object orientation for application development has increased, many researchers have investigated the design of object-based programming languages for distributed and persistent programming. This paper concentrates on reviewing a number of such languages for distributed or persistent programming. In each case, the focus is on the object model supported and the mechanisms and policies employed in the implementation of distributed or persistent objects. In particular, each language reviewed has been chosen to illustrate a particular object model or implementation strategy.

Lack of bandwidth has been shown to be a major impediment to achieving realism in large scale virtual worlds with many interacting entities. Recent projects that have addressed this problem have, for the most part, been tied to a single application domain, typically the development of realistic military simulations. This paper presents a brief overview of the techniques to achieve scale adopted by the object execution environment of the void shell, a virtual world development toolkit.

This paper presents an overview of the Comandos distributed application platform. It begins by presenting the scope and objectives of the platform before introducing its main concepts, design choices and overall architecture. An overview of the various prototype implementations of the platform undertaken within the Comandos project is also presented. In addition, the paper provides an introduction to the other papers on Comandos in this issue and sets the context for the research reported therein.

In this paper we present some ideas on the functionality that should be incorporated into an object-oriented distributed system to support distributed and parallel programming. The work is based on practical experience in developing several substantial distributed and parallel applications on the Amadeus platform. Related work in the area is sketched.

Atomic transactions are now a familiar paradigm for distributed programming and have been provided in a number of object-oriented languages. Much effort has also been expended on developing open transaction processing systems which support distributed transactions involving multi-vendor database systems. This paper addresses a number of issues that arise in combining object-oriented distributed programming with open transaction processing. We describe an approach to supporting transactions which can access objects and other resource types, such as files and records, consistently, and which is independent of the use of any particular object-oriented programming language. We discuss both the design of a generic run-time interface which provides language independent support for atomic objects and transactions and, following the X/Open model for open transaction processing, the design of an interface between the transaction manager and a resource manager which is suitable for the requirements of object-oriented systems. We illustrate our approach by describing the transaction sub-system of the Amadeus/RelaX implementation of the Comandos platform which supports a number of popular object-oriented languages and has been integrated with an existing relational database system.

Many object-oriented programming language implementations have been estcndcd to support persistence, dist,ribut,ion or atomicity by integrating the necessary a,dditional support, with t,he language's runt,ime library.We argue tha.t a better approach is to provide a. Generic Runtime library (the GRT) which imple-ments that part of the support which is independent.of any langua.ge.The GRT should be designed to interfa.ce to a langua.ge'sexisting runtime in such a way that the language's local object reference format and invocation mechanism can be retained.Hence exist.ingcompilers do not necessarily have to be modified, and a range of different object,-oriented languages can be supporkd simultaneously.This a.pproach 1la.s significant merits including: the ease with which a la.nguage ca.n be extended; the sophistication of the underlying support immediately available to a. la.nguage implementer; a.nd the ability to support fine-grain& language interworking.