Powered by
Conference Publishing Consulting

2012 4th International Workshop on Hot Topics in Software Upgrades (HotSWUp), June 3, 2012, Zurich, Switzerland

HotSWUp 2012 – Proceedings

Contents - Abstracts - Authors

4th International Workshop on Hot Topics in Software Upgrades (HotSWUp)

Preface

Title Page

Foreword
Many diverse research areas are concerned with building large, evolving, highly-available systems. The fourth edition of the HotSWUp workshop, which has focused on languages and information systems in three successful editions co-located with the OOPSLA and ICDE conferences, is co-located with ICSE and focuses on software engineering. We would like to sincerely welcome you to HotSWUp 2012.

Zuerichsee

How to Have Your Cake and Eat It Too: Dynamic Software Updating with Just-in-Time Overhead
Rida A. Bazzi, Bryan Topp, and Iulian Neamtiu
(Arizona State University, USA; UC Riverside, USA)
We consider the overhead incurred by programs that can be updated dynamically and argue that, in general, and regardless of the mechanism used, the program must incur an overhead during normal execution. We argue that the overhead during normal execution of the updateable program need not be as high as the overhead for the updated program. In light of the fundamental limitations and the differences in the overhead that must be incurred by the updateable and updated programs, we propose a new mechanism for dynamic software update based on a new shifting gears approach. The mechanism attempts to incur just the required overhead depending on the stage of update the application is in. Before an update the execution incurs low overhead and when an update occurs the execution incurs higher overhead which reverts to low overhead as the execution progresses. We evaluate the mechanism by modifying an application by hand. Preliminary performance numbers show that the mechanism performs better than existing mechanisms for dynamic software update.
Article Search
A Study of Dynamic Software Update Quiescence for Multithreaded Programs
Christopher M. Hayden, Karla Saur, Michael Hicks, and Jeffrey S. Foster
(University of Maryland, USA)
Dynamic software updating (DSU) techniques show great promise in allowing vital software services to be upgraded without downtime, avoiding dropped connections and the loss of critical program state. For multithreaded programs, DSU systems must balance correctness and timeliness. To simplify reasoning that an update is correct, we could limit updates to take place only when all threads have blocked at well-defined update points. However, several researchers have pointed out that this approach poses the risk of delaying an update for too long, even indefinitely, and therefore have developed fairly complicated mechanisms to mitigate the risk. This paper argues that such mechanisms are unnecessary by demonstrating empirically that many multithreaded programs can be updated with minimal delay using only a small number of manually annotated update points. Our study of the time taken for all of the threads in six real-world, event-driven programs to reach their update points ranged from 0.155 to 107.558 ms, and most were below 1 ms.
Article Search
Towards Standardized Benchmarks for Dynamic Software Updating Systems
Edward K. Smith, Michael Hicks, and Jeffrey S. Foster
(University of Maryland, USA)
Dynamic Software Updating (DSU) has been an active topic of research for at least the last 30 years. However, despite many recent advances, DSU has yet to see widespread adoption and deployment in practice. In this paper, we review a slice of the history of DSU research to study how DSU for C has evolved over the last two decades. We examine the ways DSU systems are evaluated in the research literature. We identify several shortcomings of the evaluation criteria that have been used, and propose key improvements. We believe that using better evaluation criteria can guide DSU research to produce systems that will be more practical, flexible, and usable.
Article Search

Uetliberg

Safe and Automated State Transfer for Secure and Reliable Live Update
Cristiano Giuffrida and Andrew S. Tanenbaum
(VU University Amsterdam, Netherlands)
Traditional live update systems offer little or no automated support for state transfer between two different program versions with changes in the program state. In this paper, we report our efforts to build a safe and automated state transfer framework for C programs that requires a minimal number of program state annotations and handles common structural state changes with no programmer assistance. To handle more complex state transformations, the framework includes a number of extension mechanisms designed to minimize the overall programming effort. Our experience with real-world programs suggests that our framework can handle all the standard C idioms and support safe and automated state transfer for complex state changes. We believe our approach is effective in several update scenarios and significantly raises the bar on the security and reliability of live update.
Article Search
Atomic Dynamic Upgrades Using Software Transactional Memory
Luís Pina and João Cachopo
(Technical University of Lisbon, Portugal; INESC-ID, Portugal)
In this paper, we propose the use of a Software Transactional Memory to implement a Dynamic Software Upgrade system that combines two desirable properties. First, it provides a simple semantics to the developer, while allowing upgrades to occur atomically, concurrently with the execution of the program. Second, it converts the program's data lazily, as data is progressively accessed by the execution of the upgraded program. We present also experimental results that show that our lazy approach to software upgrades is able to upgrade a system without affecting significantly the maximum response time of the system's operations, whereas an immediate approach shows values of maximum response time up to three orders of magnitude higher.
Article Search
A Generic Approach for Deploying and Upgrading Mutable Software Components
Sander Van der Burg
(TU Delft, Netherlands)
Deploying and upgrading software systems is typically a labourious, error prone and tedious task. To deal with the complexity of a software deployment process and to make this process more reliable, we have developed Nix, a purely functional package manager as well as an extension called Disnix, capable of deploying service-oriented systems in a network of machines. Nix and its applications only support deployment of immutable components, which never change after they have been built. However, not all components of a software system are immutable, such as databases. These components must be deployed by other means, which makes deployment and upgrades of such systems difficult, especially in large networks. In this paper, we analyse the properties of mutable components and we propose Dysnomia, a deployment extension for mutable components.
Article Search

Baden

Verification of Software Changes with ExpliSAT
Hana Chockler and Sitvanit Ruah
(IBM Research, Israel)
We describe an algorithm for efficient formal verification of changes in software built on top of a model-checking procedure that traverses the control flow graph explicitly while representing the data symbolically. The main idea of our algorithm is to guide the control flow graph exploration first to the paths that traverse through the changed nodes in the graph. We implemented this idea on top of the concolic model checker ExpliSAT and the experimental results on real programs show a significant improvement in performance compared to re-verification of the whole program, when the change involves a small fraction of paths on the control flow graph.
Article Search
Multi-version Software Updates
Cristian Cadar and Petr Hosek
(Imperial College London, UK)
Software updates present a difficult challenge to the software maintenance process. Too often, updates result in failures, and users face the uncomfortable choice between using an old stable version which misses recent features and bug fixes, and using a new version which improves the software in certain ways, only to introduce other bugs and security vulnerabilities. In this position paper, we propose a radically new approach for performing software updates: whenever a new update becomes available, instead of upgrading the software to the new version, we instead run the new version in parallel with the old one. By carefully coordinating their executions and selecting the behavior of the more reliable version when they diverge, we can preserve the stability of the old version without giving up the features and bug fixes added to the new version. We are currently focusing on a prototype system targeting multicore CPUs, but we believe this approach could also be deployed on other parallel platforms, such as GPGPUs and cloud environments.
Article Search
Theseus: Whole Updates of Java Server Applications
Erwann Wernli
(University of Bern, Switzerland)
We present a novel approach to update server applications in Java. In our approach, different versions of the code coexist in the system, but are isolated into distinct contexts. The server can switch from one context to another incrementally in order to process incoming requests. Our approach has the following characteristics: (1) updatability is defined and added to the application by developers, (2) no syntax is added to the language and the update is controlled via the manipulation of objects, (3) the whole system is migrated lazily and eventually replaces the old system, (4) it is safe to update global entities anytime and there is no need to reach update points. We demonstrate our approach by updating the Jetty web server.
Article Search

proc time: 0.11