Dynamic Software Updates Research Articles

Scheduling Dynamic Software Updates in Mobile Robots

We present NeRTA ( Ne xt R elease T ime A nalysis), a technique to enable dynamic software updates for low-level control software of mobile robots. Dynamic software updates enable software correction and evolution during system operation. In mobile robotics, they are crucial to resolve software defects without interrupting system operation or to enable on-the-fly extensions. Low-level control software for mobile robots, however, is time sensitive and runs on resource-constrained hardware with no operating system support. To minimize the impact of the update process, NeRTA safely schedules updates during times when the computing unit would otherwise be idle. It does so by utilizing information from the existing scheduling algorithm without impacting its operation. As such, NeRTA works orthogonal to the existing scheduler, retaining the existing platform-specific optimizations and fine-tuning, and may simply operate as a plug-in component. To enable larger dynamic updates, we further conceive an additional mechanism called bounded reactive control and apply mixed-criticality concepts. The former cautiously reduces the overall control frequency, whereas the latter excludes less critical tasks from NeRTA processing. Their use increases the available idle times. We combine real-world experiments on embedded hardware with simulations to evaluate NeRTA. Our experimental evaluation shows that the difference between NeRTA’s estimated idle times and the measured idle times is less than 15% in more than three-quarters of the samples. The combined effect of bounded reactive control and mixed-criticality concepts results in a 150+% increase in available idle times. We also show that the processing overhead of NeRTA and of the additional mechanisms is essentially negligible.

TOAST: Automated Testing of Object Transformers in Dynamic Software Updates

TOAST: Automated Testing of Object Transformers in Dynamic Software Updates

Dynamic Software Updates to Enhance Security and Privacy in High Availability Energy Management Applications in Smart Cities

The Internet of Things (IoT) and Industrial Internet of Things (IIoT) trends, where high connectivity is envisioned, are giving rise to new applications, services, and paradigms, such as smart cities. Due to this connectivity and information sharing features, security, and privacy protection mechanisms need to be implemented, which may become obsolete at some future time. Software updates are, then, crucial. However, software updates requiring system shutdown and restarts might not be acceptable from the business and service point of view when high availability is demanded. In this paper, a mixed-criticality software architecture and design for a building energy management system, built upon the Cetratus runtime framework, is presented, where partitioning techniques are employed to ensure temporal and spatial isolation. Through this framework, software updates are dynamically accomplished, without the need for system shutdown and restarts. A live patching example is also presented, where customers privacy is enhanced by means of homomorphic encryption.

Dynamic Software Updating of IEC 61499 Implementation Using Erlang Runtime System

Dynamic Software Updates (DSU) permit to decrease downtimes caused by updates or bug fixes and thus increase productivity, which is an ever present target during development of industrial production systems. This study implements a compiler to transform an IEC 61499 model into executable code for the Erlang Runtime System (ERTS) which natively features DSU, and investigates its feasibility. As a case study, a small production plant is implemented and updated on-the-fly with new features and safety fixes. This case study shows that DSU by using the ERTS is feasible. However, additional information for the update structure, content and schedule is required from an external source.

Formalization and Verification of Behavioral Correctness of Dynamic Software Updates

Dynamic Software Updating (DSU) is a technique of updating running software systems on-the-fly. Whereas there are some studies on the correctness of dynamic updating, they focus on how to deploy updates correctly at the code level, e.g., if procedures refer to the data of correct types. However, little attention has been paid to the correctness of the dynamic updating at the behavior level, e.g., if systems after being updated behave as expected, and if unexpected behaviors can never occur. We present an algebraic methodology of specifying dynamic updates and verifying their behavioral correctness by using off-the-shelf theorem proving and model checking tools. By theorem proving we can show that systems after being updated indeed satisfy their desired properties, and by model checking we can detect potential errors. Our methodology is general in that: (1) it can be applied to three updating models that are mainly used in current DSU systems; and (2) it is not restricted to dynamic updates for certain programming models.

Report on the fourth workshop on hot topics in software upgrades (HotSWUp 2012)

The Fourth Workshop on Hot Topics in Software Upgrades (HotSWUp 2012) was held on June 3, 2012 in Zurich, Switzerland. The workshop was co-located with ICSE 2012. The goal of HotSWUp is to identify, through interdisciplinary collaboration, cutting-edge research ideas for implementing software upgrades. The workshop combined presentations of peer-reviewed research papers with a keynote speech on how empirical software engineering can help reduce update-induced failures. The audience included researchers and practitioners from academia and industry. In addition to the technical presentations, the program allowed ample time for discussions, which were driven by debate questions provided in advance by the presenters. HotSWUp provides a premier forum for discussing problems that are often considered niche topics in the established research communities. For example, the technical discussions at HotSWUp'12 covered dynamic software updates, package management tools, using model-checking and verification to verify updates, empirical software engineering and repository mining, and highlighted many synergies among these and other topics.

Automating object transformations for dynamic software updating

Dynamic software updating (DSU) systems eliminate costly downtime by dynamically fixing bugs and adding features to executing programs. Given a static code patch, most DSU systems construct runtime code changes automatically. However, a dynamic update must also specify how to change the running program's execution state, e.g., the stack and heap, to make it compatible with the new code. Constructing such state transformations correctly and automatically remains an open problem. This paper presents a solution called Targeted Object Synthesis (TOS). TOS first executes the same tests on the old and new program versions separately, observing the program heap state at a few corresponding points. Given two corresponding heap states, TOS matches objects in the two versions using key fields that uniquely identify objects and correlate old and new-version objects. Given example object pairs, TOS then synthesizes the simplest-possible function that transforms an old-version object to its new-version counterpart. We show that TOS is effective on updates to four open-source server programs for which it generates non-trivial transformation functions that use conditionals, operate on collections, and fix memory leaks. These transformations help programmers understand their changes and apply dynamic software updates.

JavAdaptor—Flexible runtime updates of Java applications

SUMMARYSoftware is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the program's architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JavAdaptor combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approach's applicability and performance in non‐trivial case studies and compare it with existing dynamic software update approaches. Copyright © 2012 John Wiley & Sons, Ltd.

Report on the third workshop on hot topics in software upgrades (HotSWUp'11)

Report on the third workshop on hot topics in software upgrades (HotSWUp'11). The workshop combined presentations of peer-reviewed research papers with a keynote speech on the practical issues related to performing large-scale upgrades. The audience included researchers and practitioners from academia, industry, and government. In addition to the technical presentations, the program allowed ample time for discussions, which were driven by debate questions provided in advance by the presenters. HotSWUp provides a premier forum for discussing problems that are often considered niche topics in the established research communities. For example, the technical discussions at HotSWUp'11 covered dynamic software updates, package management tools, database schema upgrades, upgrades of systems with real-time constraints, upgrading satellite software, and highlighted many synergies among these and other topics.

Report on the second ACM workshop on hot topics in software upgrades (HotSWUp'09)

The Second ACM SIGPLAN Workshop on Hot Topics in Software Upgrades (HotSWUp'09) was held on 25 October 2009 in Orlando, FL. The workshop was co-located with OOPSLA 2009 and was sponsored by ACM SIGPLAN. Twenty researchers and practitioners, from the programming languages, systems, software engineering and database communities, attended HotSWUp'09. The goal of HotSWUp is to identify, through interdisciplinary collaboration, cutting-edge research ideas for implementing software upgrades. The workshop combined presentations of peer-reviewed research papers with invited presentations from well-known experts and a keynote speech on the practical issues related to performing large-scale upgrades. The audience included researchers and practitioners from academia, the industry (Facebook, ABB, Oracle) and the open-source community (AppUpdater). In addition to the technical presentations, the program allowed ample time for discussions, which were driven by debate questions provided in advance by the presenters HotSWUp provides a premier forum for discussing problems that are often considered niche topics in the established research communities. For example, the technical discussions at HotSWUp'09 covered dynamic software updates, package management tools, database schema upgrades, upgrades of systems with real-time constraints, etc., and highlighted many synergies among these topics. Perhaps more interestingly, the industry presentations provided real-world examples of systems that a have strong requirement for online upgrades. These examples emphasized the magnitude of the software upgrade problems that the industry is facing today

Dynamic software updates for parallel high‐performance applications

AbstractDespite using multiple concurrent processors, a typical high‐performance parallel application is long‐running, taking hours, even days to arrive at a solution. To modify a running high‐performance parallel application, the programmer has to stop the computation, change the code, redeploy, and enqueue the updated version to be scheduled to run, thus wasting not only the programmer's time, but also expensive computing resources. To address these inefficiencies, this article describes how dynamic software updates (DSU) can be used to modify a parallel application on the fly, thus saving the programmer's time and using expensive computing resources more productively. The net effect of updating parallel applications dynamically can reduce the total time that elapses between posing a problem and arriving at a solution, otherwise known as time‐to‐discovery. To explore the benefits of dynamic updates for high performance applications, this article takes a two‐pronged approach. First, we describe our experiences of building and evaluating a system for dynamically updating applications running on a parallel cluster. We then review a large body of literature describing the existing state of the art in DSU and point out how this research can be applied to high‐performance applications. Our experimental results indicate that DSU have the potential to become a powerful tool in reducing time‐to‐discovery for high‐performance parallel applications. Copyright © 2010 John Wiley & Sons, Ltd.

Contextual effects for version-consistent dynamic software updating and safe concurrent programming

This paper presents a generalization of standard effect systems that we call contextual effects . A traditional effect system computes the effect of an expression e . Our system additionally computes the effects of the computational context in which e occurs. More specifically, we computethe effect of the computation that has already occurred(the prior effect ) and the effect of the computation yet to take place (the future effect ). Contextual effects are useful when the past or future computation of the program is relevant at various program points. We present two substantial examples. First, we show how prior and future effects can be used to enforce transactional version consistency (TVC), a novel correctness property for dynamic software updates. TV Censures that programmer-designated transactional code blocks appear to execute entirely at the same code version, even if a dynamic update occurs in the middle of the block. Second, we show how future effects can be used in the analysis of multi-threaded programs to find thread-shared locations. This is an essential step in applications such as data race detection.

Smart Phased Array SoCs: A Novel Application for Advanced SiGe HBT BiCMOS Technology

As BiCMOS IC technology continues to advance in scaling and performance, new applications are continually enabled. One such concept is a smart phased array system on a chip (SoC). The combination of high-performance SiGe heterojunction bipolar transistor (HBT) bipolar devices, well-characterized RF/analog passive components, and dense CMOS digital technology provides the capability to create large multielement, electronically tunable phased arrays with onboard processing intelligence, inside a single die. This SoC will have superior characteristics of lower cost, weight, and size as compared to the large multichip, multitechnology, and multipackage systems in deployment today. Furthermore, using reconfigurable logic and embedded memory, this SoC has the advantage of dynamic software and digital signal processing engine updates, without expensive redesigns of the chip. This publication will describe the necessary ingredients to create such an SoC as well as relevant applications of smart phased arrays that require an SiGe HBT BiCMOS technology. Potential markets for this technology include communications systems, weather tracking, radio astronomy, automotive radar, cellular basestation capacity improvement, satellite and aerial resource imaging, ground-level airplane collision avoidance, as well as military tracking and guidance systems.

Mutatis mutandis

Dynamic software updates can be used to fix bugs or add features to a running program without downtime. Essential for some applications and convenient for others, low-level dynamic updating has been used for many years. Perhaps surprisingly, there is little high-level understanding or language support to help programmers write dynamic updates effectively.To bridge this gap, we present Proteus, a core calculus for dynamic software updating in C-like languages that is flexible, safe, and predictable. Proteus supports dynamic updates to functions (even active ones), to named types and to data, allowing on-line evolution to match source-code evolution as we have observed it in practice. We ensure updates are type-safe by checking for a property we call "con-freeness" for updated types t at the point of update. This means that non-updated code will not use t concretely beyond that point (concrete usages are via explicit coercions) and thus t's representation can safely change. We show how con-freeness can be enforced dynamically for a particular program state. We additionally define a novel and efficient static updateability analysis to establish con-freeness statically, and can thus automatically infer program points at which all future (well-formed) updates will be type-safe. We have implemented our analysis for C and tested it on several well-known programs.