George T. Heineman

Dynamic plan migration for continuous queries over data streams

Dynamic plan migration is concerned with the on-the-fly transition from one continuous query plan to a semantically equivalent yet more efficient plan. Migration is important for stream monitoring systems where long-running queries may have to withstand fluctuations in stream workloads and data characteristics. Existing migration methods generally adopt a pause-drain-resume strategy that pauses the processing of new data, purges all old data in the existing plan, until finally the new plan can be plugged into the system. However, these existing strategies do not address the problem of migrating query plans that contain stateful operators, such as joins. We now develop solutions for online plan migration for continuous stateful plans. In particular, in this paper, we propose two alternative strategies, called the moving state strategy and the parallel track strategy, one exploiting reusability and the second employs parallelism to seamlessly migrate between continuous join plans without affecting the results of the query. We develop cost models for both migration strategies to analytically compare them. We embed these migration strategies into the CAPE [7], a prototype system of a stream query engine, and conduct a comparative experimental study to evaluate these two strategies for window-based join plans. Our experimental results illustrate that the two strategies can vary significantly in terms of output rates and intermediate storage spaces given distinct system configurations and stream workloads.

Component-Based Dynamic QoS Adaptations in Distributed Real-Time and Embedded Systems

Large scale distributed real time and embedded (DRE) applications are complex entities that are often composed of different subsystems and have stringent Quality of Service (QoS) requirements. These subsystems are often developed separately by different developers increasingly using commercial off-the shelf (COTS) middleware. Subsequently, these subsystems need to be integrated, configured to communicate with each other, and distributed. However, there is currently no standard way of supporting these requirements in existing COTS middleware. While recently emerging component-based middleware provides standardized support for packaging, assembling, and deploying, there is no standard way to provision QoS required by the DRE applications. We have previously introduced a QoS encapsulation model, qoskets, as part of our QuO middleware framework that can dynamically adapt to resource constraints. In this paper we introduce implementing these QoS behaviors as components that can be assembled with other application components. The task of ensuring QoS then becomes an assembly issue. To do so we have componentized our QuO technology instead of integrating QuO into the middleware as a service. To date, we have demonstrated our approach of QoS provisioning in MICO, CIAO, and Boeing’s Prism component middleware. We present experimental results to evaluate the overhead incurred by these QoS provisioning components in the context of CIAO CCM. We use a simulated Unmanned Aerial Vehicle (UAV) application as an illustrative DRE application for the demonstration of QoS adaptations using qosket components.

Evolving legacy system features into fine-grained components

There is a constant need for practical, efficient, and cost-effective software evolution techniques. We propose a novel evolution methodology that integrates the concepts of features, regression tests, and component-based software engineering (CBSE). Regression test cases are untapped resources, full of information about system features. By exercising each feature with its associated test cases using code profilers and similar tools, code can be located and refactored to create components. These components are then inserted back into the legacy system, ensuring a working system structure. This methodology is divided into three parts. Part one identifies the source code associated with features that need evolution. Part two deals with creating components and part three measures results. By applying this methodology, AFS has successfully restructured its enterprise legacy system and reduced the costs of future maintenance. Additionally, the components that were refactored from the legacy system are currently being used within a web-enabled application.

Joining punctuated streams

We focus on stream join optimization by exploiting the constraints that are dynamically embedded into data streams to signal the end of transmitting certain attribute values. These constraints are called punctuations. Our stream join operator, PJoin, is able to remove no-longer-useful data from the state in a timely manner based on punctuations, thus reducing memory overhead and improving the efficiency of probing. We equip PJoin with several alternate strategies for purging the state and for propagating punctuations to benefit down-stream operators. We also present an extensive experimental study to explore the performance gains achieved by purging state as well as the trade-off between different purge strategies. Our experimental results of comparing the performance of PJoin with XJoin, a stream join operator without a constraint-exploiting mechanism, show that PJoin significantly outperforms XJoin with regard to both memory overhead and throughput.

An architecture for multi-user software development environments

We present an architecture for multi-user software development environments, covering general, process-centered and rule-based MUSDEs. Our architecture is founded on componentization, with particular concern for the capability to replace the synchronization component–to allow experimentation with novel concurrency control mechanisms–with minimal effects on other components while still suporting integration. The architecture has been implemented for the MARVEL SDE.

Rule chaining in Marvel: dynamic binding of parameters

Marvel is a software development environment that uses a rule-based model of the development process. When a user issues a command, Marvel invokes the corresponding rule and binds the rules formal parameter to the object selected by the user. If firing the rule changes the object in a way that satisfies the conditions of other rules, Marvel automatically fires each of these rules and tries to bind their formal parameters to objects. Marvel must infer which objects to bind to the formal parameters of the rules in the chain. A problem arises when the classes of the objects manipulated by the rules are different, because Marvel has to determine which object to bind to the parameter of each rule in the chain. Recursive data definitions cause chaining between rules that act on different objects in the same class. Methods developed to address this chaining problem are discussed. >

A model for designing adaptable software components

The widespread construction of software systems from pre-existing, independently developed software components will only occur when application builders can adapt software components to suit their needs. We propose that software components provide two interfaces-one for behavior and one for adapting that behavior as needed. The ADAPT framework presented in the paper supports both component designers in creating components that can easily be adapted, and application builders in adapting software components. The motivating example, using Java-Beans, shows how adaptation, not customization, is the key to component based software.

Emerging technologies that support a software process life cycle

The goal of developing quality software can be achieved by focusing on the improvement of both product quality and process quality. While the traditional focus has been on product quality, there is an increased awareness of the benefits of improving the quality of the processes used to develop and support those products. These processes are key elements in understanding and improving the practice of software engineering. In this paper, existing objectives for the development and application of models of software processes are restated, and current research sponsored by the IBM Centre for Advanced Studies (CAS) is discussed as it applies to furthering each of the objectives. A framework is also presented that relates the research work to the various sectors of a software process life cycle. The on-going research involves four universities, CAS, and collaboration with IBM Toronto Laboratory developers.

Adaptation and software architecture

1. ABSTRACT This paper focuses on the need to adapt software components and software architectures. Too often, examples from the literature avoid the difficult problem of constructing a software system from sets of (possibly independently constructed) software components. Consider the following example: given a set of components, an application builder attempts to construct a software system. Along the way, however, some components are adapted with new code to suit the requirements of the final application. If the components have architectural specifications, how are these adaptations reflected? In particular, changes in the component implementation (i.e., new classes, modified methods, new lines of code) must be reflected in the specification of the component (i.e., ports). This problem is more important than simply keeping documentation synchronized with software -the architectural description of a software system is essential in understanding the interconnections between the various software components. 1.1

An architecture for integrating concurrency control into environment frameworks

Layered and componentized systems promise substantial benefits from dividing responsibilities, but it is still unresolved how to construct a system from pre-esisting, independently developed pieces. Good solutions to this problem, in general or for specific classes of components, should reduce duplicate implementation efforts and promote reuse of large scale subsystems. We tackle the domain of software development environments and present an architecture for retrofitting external concurrency control components onto existing environment frameworks. We describe a sample ECC component, explain how we added concurrency control to a commercial product that had none, and briefly sketch how we replaced the concurrency control mechanism of a research system.