Peter Dickman

Zones, contracts and absorbing changes: an approach to software evolution

This paper describes a novel approach to managing the evolution of distributed, persistent systems at run-time. This is achieved by partitioning a system into disjoint zones, each of which can be evolved without affecting code in any other. Contracts are defined between zones, making type-level interdependencies and inter-zone communication explicit. Programmer supplied code is added to the running system, at the boundary between zones, to constrain the scope of changes. A change methodology is presented which the software engineer uses to help describe and manage the evolution of the system. Knowledge of the application semantics is essential when evolving a system and our approach allows the engineer to concentrate on these semantic aspects of change. Our Java-based demonstration platform and methodology reduce or remove some of the burdensome tasks the software engineer is normally expected to perform when changing a system, making evolution more tractable.

DRASTIC: A run-time architecture for evolving, distributed, persistent systems

Modern systems must be adaptable — to changing requirements, bug-fixes, new technologies and reconfiguration. For critical applications this must be possible at run-time; for complex applications it should be limitable to major sub-divisions of the system. The DRASTIC architecture addresses these goals by exploiting object persistence and distributed systems implementation techniques. It enables run-time changes of types, implementations, and the system configuration. This is based on a novel architectural abstraction of locality for evolution, called the ‘zone’. Contracts between zones automatically limit the visibility of such changes between zones. We present work in progress on DRASTICs computational model and run-time system, illustrating support for software evolution and highlighting key features of our current implementation.

A suite of testbeds for the realistic evaluation of peer-to-peer information retrieval systems

Peer-to-peer (P2P) networking continuously gains popularity among computing science researchers. The problem of information retrieval (IR) over P2P networks is being addressed by researchers attempting to provide valuable insight as well as solutions for its successful deployment. All published studies have, so far, been evaluated by simulation means, using well-known document collections (usually acquired from TREC). Researchers test their systems using divided collections whose documents have been previously distributed to a number of simulated peers. This practice leads to two problems: First, there is little justification in favour of the document distributions used by relevant studies and second, since different studies use different experimental testbeds, there is no common ground for comparing the solutions proposed. In this work, we contribute a number of different document testbeds for evaluating P2P IR systems. Each of these has been deduced from TRECs WT10g collection and corresponds to different potential P2P IR application scenarios. We analyse each methodology and testbed with respect to the document distributions achieved as well as to the location of relevant items within each setting. This work marks the beginning of an effort to provide more realistic evaluation environments for P2P IR systems as well as to create a common ground for comparisons of existing and future architectures.

Birrell's distributed reference listing revisited

The Java RMI collector is arguably the most widely used distributed garbage collector. Its distributed reference listing algorithm was introduced by Birrell et al. in the context of Network Objects, where the description was informal and heavily biased toward implementation. In this article, we formalize this algorithm in an implementation-independent manner, which allows us to clarify weaknesses of the initial presentation. In particular, we discover cases critical to the correctness of the algorithm that were not accounted for by Birrell. We use our formalization to derive an invariant-based proof of correctness of the algorithm that avoids notoriously difficult temporal reasoning. Furthermore, we offer a novel graphical representation of the state transition diagram, which we use to provide intuitive explanations of the algorithm and to investigate its tolerance to faults in a systematic manner. Finally, we examine how the algorithm may be optimized, either by placing constraints on message channels or by tightening the coupling between the application program and distributed garbage collector.

Variable-rate data sampling for low-power microsystems using modified Adams methods

A method for variable-rate data sampling is proposed for the purpose of low-power data acquisition in a small footprint microsystem. The procedure enables energy saving by utilizing dynamic power management techniques and is based on the Adams-Bashforth and Adams-Moulton multistep predictor-corrector methods for ordinary differential equations. Newton-Gregory backward difference interpolation formulae and past value substitution are used to facilitate sample rate changes. It is necessary to store only 2m+1 equispaced past values of t and the corresponding values of y, where y=g(t), and m is the number of steps in the Adams methods. For the purposes of demonstrating the technique, fourth-order methods are used, but it is possible to use higher orders to improve accuracy if required.

Garbage collection and memory management

This document is the report for the OOPSLA97 Workshop on Garbage Collection and Memory Management. The one-day workshop was organ&d by Paul R. Wilson of the University of Texas at Austin, USA and Peter Dickman and Huw Evans of the University of Glasgow, Scotland. Fifteen papers were accepted and eighteen presentations were made. The sessions were divided into: Instrumentation and Evaluation; Java GC Implementation; Finding Stuff, Commercialising GC; Distributed Garbage Collection, Miscellany, Workshop Wind-up.

Incremental, Distributed Orphan Detection and Actor Garbage Collection Using Graph Partitioning and Euler Cycles

A new algorithm is presented for incremental, distributed, concurrent garbage collection in systems with Actors. The algorithm also serves to detect orphan computations at low cost, as a side-effect of garbage collection, and permits the accurate elimination of unnecessary work without prejudicing the integrity of applications. Unlike all previous related algorithms, the new technique efficiently constructs a graph representation of the reachability relation within which Euler cycles can be used to determine the garbage objects. The new algorithm uses O(N + E) space and O(N + E) time, in the worst-case, to collect a graph of N objects and E references; this is comparable to one previously known algorithm and superior to all others (which require O(N2) time and O(N + E) space in the worst-case). The new algorithm also avoids an uneven space utilisation problem exhibited by the only other O(N + E) time algorithm, making it more suitable for use in non-shared-memory distributed systems.

Diffusion tree restructuring for indirect reference counting

A new variant algorithm for distributed acyclic garbage detection is presented for use in hybrid garbage collectors. The existing fault-tolerance of Piquers Indirect Reference Counting (IRC) is qualitatively improved by this new approach. The key insight that underpins this work is the observation that the parent of a node in the IRC diffusion tree need not remain constant. The new variant exploits standard mechanisms for implementing diffusion trees and remote references, using four simple low-cost techniques to dynamically restructure the trees to reduce their depth. This variant reduces third-party dependencies, which make standard IRC vulnerable to process failure, while retaining tolerance of message reordering and without incurring substantial overheads. The paper carefully motivates the algorithm, presents the full technical basis for its development, provides a clear explanation of implementation details and includes an initial discussion of performance issues.

The Design and Development of an RFID-enabled asset tracking system for challenging environments

This paper presents an overview of the Phalanx software system from Spartan Solutions. This RFID-based asset-tracking solution exploits robust handheld PDA-based scanners with intermittent-wireless connectivity to integrate operational activities and ERP/logistical information systems for the plant-rental and oil/gas sectors. Unusual challenges in the operating environment and user community have been overcome using novel techniques and unique combinations of technology and methodology. The Phalanx system is an exemplar of an innovative RFID application overcoming significant data management problems. Wireless security issues have been addressed and the system includes internal web-services interfaces that are now being extended for exploitation in operational and corporate oversight applications. The middleware platform enables integration of previously separate applications, extending business processes into the operational domain. The experiences reported in these two case studies have been gained in development, deployment and use in several countries and offer an insight into the effectiveness of an RFID-enabled infrastructure for improved business performance in new and challenging commercial sectors.

Peer-to-Peer Programming with Teaq

This paper introduces Teaq, a new peer-to-peer programming model and implementation that places processes into a self-healing, ordered spanning tree, across which distributed object queries are routed. The programmer has control over where in the tree their process resides, how their queries are routed through the tree, and how result objects are generated and passed back to the query initiator. Default implementations are provided that the programmer may specialise. This paper introduces the two main algorithms for maintaining the tree and routing queries.