The ability to adapt software systems to fix bugs, add/change features without restarting is becoming important for many domains including but not limited to finance, social networking, control systems, etc. Fortunately, many ideas have begun to emerge under the umbrella term "dyanamic updating" to solve this problem. Dynamic updating is critical to address certain software evolution needs. Dynamic updating literature evaluates such systems in terms of coverage (i.e. what type of code changes are supported) and performance. However, we do not have a technique to analyze whether certain updating solution, based on its costs and benefits, is suitable for an application. In this paper, we present a quantitative analysis model to fill this gap. Our model is parameterized and it can be instantiated with application-specific valuation functions. Given the software evolution history of the application under consideration, our model allows rigorous comparisons of the value of different software updating schemes (e.g. online vs. offline). We illustrate our model using two case studies inspired from the the evolution history of Xerces XML parser library and Apache httpd web server. Other case studies and evaluation examples are presented in our technical report [Gharaibeh, Rajan and Chang 09]. The proposed analysis scheme can serve system architects in evaluating their current updating scheme. For example, to audit the system's value during previous development cycles and whether a different updating scheme will generate higher value.

Dynamic deployment is an important feature of an aspectoriented language design that has many applications, e.g. in runtime monitoring, runtime adaptation to fix bugs or add features to long running applications, runtime update of dynamic policy changes, etc. Many recently proposed language designs support these use cases. In previous work, researchers have demonstrated that the ability to support unanticipated deployment enables simpler and often more efficient implementations. These works have addressed an important subset of aspect-oriented features namely those that can be represented as the pointcut-advice model. In this work, we describe the design, formal semantics, and implementation of our strategy for efficiently supporting dynamic deployment of inter-type declarations, which is another important aspect-oriented feature. Additional contributions of this work are: a detailed real world case study that demonstrates the need for supporting dynamic deployment of intertype declaration for online update of long running applications, and a prototype based on the Jikes Research Virtual Machine that supports these features. We evaluate our prototype via a rigorous performance analysis, which shows that flexible, dynamic deployment of inter-type declarations can be efficiently supported in a Java virtual machine.

In this paper, we study the upper bounds of memory storage for two different allocators. In the first case, we consider a general allocator that can allocate memory blocks anywhere in the available heap space. In the second case, a more economical allocator constrained by the address-ordered first-fit allocation policy is considered. We derive the upper bound of memory usage for all allocators and present a systematic approach to search for allocation/deallocation patterns that might lead to the largest fragmentation. These results are beneficial in embedded systems where memory usage must be reduced and predictable because of lack of swapping facility. They are also useful in other types of computing systems.

Dynamic software updating provides many benefits, e.g. in runtime monitoring, runtime adaptation to fix bugs in long running applications, etc. Although it has several advantages, no quantitative analysis of its costs and revenue are available to show its benefits or limitations especially in comparison with other software updating schemes. To address this limitation in evaluating software updating schemes, we contribute a quantitative cost/benefit analysis based on net option-value model, which stems from the analysis of financial options. Our model expresses the relation between added value and paid cost in mathematical forms. We have used this model to evaluate the revenue from dynamic updating in two case studies featuring Xerces and MobileMedia. These studies reveal the set of parameter values that render dynamic updating effective. We also compared two previously published dynamic updating schemes and observed how the perceived performance and coverage of different updating systems affects their relative gain.

Dynamic deployment is an important feature of an aspect-oriented language design that has many software engineering benefits, e.g. in runtime monitoring, runtime adaptation to fix bugs or add features to long running applications, runtime update of dynamic policy changes, etc. Many recently proposed language designs support these use cases. In previous work, researchers have demonstrated that the ability to support unanticipated deployment enables simpler and often more efficient implementations. These works have addressed an important subset of aspect-oriented features namely those that can be represented as the pointcut-advice model. In this work, we describe the design, formal semantics, and implementation of our strategy for efficiently supporting dynamic deployment of inter-type declarations, which is another important aspectoriented feature. Additional contributions of this work are: a detailed real world case study that demonstrates the need for supporting dynamic deployment of inter-type declaration for online update of long running applications, and a prototype based on the Jikes Virtual Machine that supports these features. We evaluate our prototype via a rigorous performance analysis, which shows that flexible, dynamic deployment of inter-type declarations can be efficiently supported in a Java virtual machine.

Abstract Refactorings of software components (e.g., libraries and frameworks) can change the APIs of the components. To use the latest version of a component, applications that reuse those APIs need to be updated. Traditionally, this is done manually, which is error-prone, tedious, and disruptive. The problem is exacerbated for long-running applications (e.g., servers) that cannot be shut down, updated, and restarted. This paper presents a practical approach and our tool, dReAM, to automat- ically and safely update running Java applications without restarting them. At the core lies a formal representation of programs to validate the composition of refactorings and other API changes to both component and application. If dReAM flnds that there are no con∞icts between components and API changes, then the running application can be safely transformed to work with the new API. To apply these API changes at runtime, dReAM extends JikesRVM, a popular JVM. Case studies on Jigsaw web server and James mail server shows that the performance overhead imposed by our update tool is less than 5%, and running applications will remain responsive during the update period. More- over, dReAM is non-intrusive for the development process: application and component developers do not need to write any annotations nor do they need to compile their programs in a special way. 0.1 Introduction Although in theory the APIs of components (e.g., libraries and frameworks)

Recent research showed that the majority of compatibility-breaking changes in a component-based, object-oriented software system are refactorings [5]. The software updating process in such system with the presence of heavily refactored application programming interface (API) is largely manual and disruptive to running, mission-critical applications, which are expected to run continuously without any interruptions. To address the online, API update issue for mission-critical systems, we have developed an online updating framework based on virtual execution environment (VEE) such as Java virtual machine. The framework extends the VEE to take the API change log, which records changes to API components, and seamlessly apply proper updates to the running system without human intervention and without shutting down the system. This framework was implemented as an extension to Jikes Research virtual machine. Our experimental study showed that our online update tool requires little overhead while maintaining the consistent state of the updated running application.

Object-oriented languages that rely on automatic dynamic memory management (i.e. Garbage Collection) are gaining popularity. More and more applications are developed using such languages. How- ever, the performance of memory management for such applications de- pends on how these applications allocate and use objects. Researchers have relied on information about object lifetime, allocation sites and ob- ject sizes to understand the performance of garbage collection and to design better collection schemes. This set of information, also referred to as Object demographics, are crucial for memory management research. However, little effort has been made to investigate schemes to obtain demographics information. The lack of demographics studies especially affects multi-threaded applications. Current schemes for tracing object lifetimes does not take into consideration the complexities associated with multi-threaded applications. With the increased interest in multi- threaded applications, the research community is in need for a thread- specific view on object demographics. Traditionally, lifetime is expressed by how many allocations were made between the object birth and death. For multi-threaded applications, the lifetime is equal to the amount of allocations made by the allocat- ing thread and any other running threads. Therefor, lifetime results are inflated by allocations from other threads and can vary with different thread scheduling scenarios. We propose a new measurement methodology that uses a vector clock of allocation. our scheme is capable of detecting needed allocations for calculating lifetime and neglect those that are a result of thread schedul- ing. In addition to accuracy, the use of vector clock allows us to observe dependencies between allocation events. The new methodology is com- pared to the conventional measurement methodology showing that the conventional method inflates object's lifetime by up to 13% for some benchmarks. In addition, using the proposed measurement method, we investigate objects demographics while showing per-thread behavior. We also show an example of using per-thread VC to understand minor col- lection cost.