Carl Bruggeman

Syntactic abstraction in Scheme

Naive program transformations can have surprising effects due to the interaction between introduced identifier references and previously existing identifier bindings, or between introduced bindings and previously existing references. These interactions can result in inadvertent binding, or capturing, of identifiers. A further complication is that transformed programs may have little resemblance to original programs, making correlation of source and object code difficult. This article describes an efficient macro system that prevents inadvertent capturing while maintaining the correlation between source and object code. The macro system allows the programmer to define program transformations using an unrestricted, general-purpose language. Previous approaches to the capturing problem have been inadequate, overly restrictive, or inefficient, and the problem of source-object correlation has been largely unaddressed. The macro system is based on a new algorithm for implementing syntactic transformations and a new representation for syntactic expressions.

Representing control in the presence of first-class continuations

Languages such as Scheme and Smalltalk that provide continuations as first-class data objects present a challenge to efficient implementation. Allocating activation records in a heap has proven unsatisfactory because of increased frame linkage costs, increased garbage collection overhead, and decreased locality of reference. However, simply allocating activation records on a stack and copying them when a continuation is created results in unbounded copying overhead. This paper describes a new approach based on stack allocation that does not require the stack to be copied when a continuation is created and that allows us to place a small upper bound on the amount copied when a continuation is reinstated. This new approach is faster than the naive stack allocation approach, and it does not suffer from the problems associated with unbounded copying. For continuation-intensive programs, our approach is at worst a constant factor slower than the heap allocation approach, and for typical programs, it is significantly faster. An important additional benefit is that recovery from stack overflow is handled gracefully and efficiently.

Specification and modeling of dynamic, distributed real-time systems

Time constrained systems which operate in dynamic environments may have unknown worst case scenarios, may have large variances in the sizes of the data and event sets that they process (and thus, have large variances in execution latencies and resource requirements), and may not be statically characterizable, even by time invariant statistical distributions. The paper presents a specification language for describing environment dependent features. Also presented is an abstract model that is constructed (statically) from the specifications, and is augmented (dynamically,) with the state of environment dependent features. The model is used to define techniques for QoS (quality of service) monitoring, QoS diagnosis, and resource allocation analysis. Experimental results show the effectiveness of the approach for specification of real time QoS, detection and diagnosis of QoS failures, and restoration of acceptable QoS via reallocation of distributed computer and network resources.

DeSiDeRaTa: QoS Management Technology for Dynamic, Scalable, Dependable, Real-Time Systems

Abstract The DeSiDeRaTa project is producing technology to enable the engineering of the emerging generation of distributed real-time systems. Such systems have rigorous Quality of Service (QoS) objectives. They must behave in a dependable manner, respond to threats in a timely fashion and provide continuous availability, even within hostile and unknown environments. To provide the desired QoS in such a context, the DeSiDeRaTa project focuses on QoS specification, dynamic QoS management middleware, and benchmarking of dynamic real-time systems. This paper discusses each of these aspects, and presents experimental results of applying DeSiDeRaTa technology to a dynamic realtime benchmark system.

Representing control in the presence of one-shot continuations

Traditional first-class continuation mechanisms allow a captured continuation to be invoked multiple times. Many continuations, however, are invoked only once. This paper introduces one-shot continuations, shows how they interact with traditional multi-shot continuations, and describes a stack-based implementation of control that handles both one-shot and multi-shot continuations. The implementation eliminates the copying overhead for one-shot continuations that is inherent in multi-shot continuations.

Guardians in a generation-based garbage collector

This paper describes a new language feature that allows dynamically allocated objects to be saved from deallocation by an automatic storage management system so that clean-up or other actions can be performed using the data stored within the objects. The program has full control over the timing of clean-up actions, which eliminates several potential problems and often eliminates the need for critical sections in code that interacts with clean-up actions. Our implementation is “generation-friendly” in the sense that the additional overhead within a generation-based garbage collector is proportional to the work already done there, and the overhead within the mutator is proportional to the number of clean-up actions actually performed.

An optimization framework for dynamic, distributed real-time systems

The paper presents a model that is useful for developing resource allocation algorithms for distributed real-time systems that operate in dynamic environments. Interesting aspects of the model include dynamic environments, utility and service levels, which provide a means for graceful degradation in resource-constrained situations and support optimization of the allocation of resources. The paper also provides an allocation algorithm that illustrates how to use the model for producing feasible, optimal resource allocations.

A resource management model for dynamic, scalable, dependable, real-time systems

Dynamic real-time systems function in unpredictable environments and have requirements that span many domains such as time, survivability, and scalability. The system requirements are typically determined as a function of the environment, further exacerbating the unpredictability of the problem. Existing solutions, for the most part, have focussed on problems for which the attributes are static, and there exists a rich set of solutions for such problems. Our problem domain has attributes that are inherently dynamic rather than static, requiring a new approach.

Threads Yield Continuations

Just as a traditional continuation represents the rest of acomputation from a given point in the computation, a subcontinuationrepresents the rest of a subcomputation from agiven point in the subcomputation. Subcontinuationsare more expressive than traditional continuations and have been shown to beuseful for controlling tree-structured concurrency, yet they havepreviously been implemented only on uniprocessors. This article describes aconcurrent implementation of one-shot subcontinuations. Like one-shotcontinuations, one-shot subcontinuations are first-class but may be invokedat most once, a restriction obeyed by nearly all programs that usecontinuations. The techniques used to implement one-shot subcontinuationsmay be applied directly to other one-shot continuation mechanisms and may begeneralized to support multi-shot continuations as well. A novel feature ofthe implementation is that continuations are implemented in terms ofthreads. Because the implementation model does not rely upon any speciallanguage features or compilation techniques, the model is applicable toany language or language implementation that supports a small set of threadprimitives.

Monitoring network QoS in a dynamic real-time system

This paper presents our design and tests of a realtime network monitoring program for DeSiDeRaTa, an existing resource management system. This monitor will assist DeSiDeRaTa in maintaining an acceptable Quality of Service (QoS) for groups of real-time applications by reporting the communication delays caused by inadequate network bandwidth. The network monitoring application we developed uses SNMP and network topology information gleaned from the DeSiDeRaTa application specification files. Network bandwidth utilization of each real-time communication path is computed, and experiments have been run to demonstrate the accuracy of these measurements.