Because software systems are imperfect, developers are forced to fix bugs and add new features. The common way of applying changes to a running system is to stop the application or machine and restart with the new version. Stopping and restarting causes a disruption in service that is at best inconvenient and at worst causes revenue loss and compromises safety. Dynamic software updating (DSU) addresses these problems by updating programs while they execute. Prior DSU systems for managed languages like Java and C# lack necessary functionality: they are inefficient and do not support updates that occur commonly in practice. This dissertation presents the design and implementation of Jvolve, a DSU system for Java. Jvolve's combination of flexibility, safety, and efficiency is a significant advance over prior approaches. Our key contribution is the extension and integration of existing Virtual Machine services with safe, flexible, and efficient dynamic updating functionality. Our approach is flexible enough to support a large class of updates, guarantees type-safety, and imposes no space or time overheads on steady-state execution. Jvolve supports many common updates. Users can add, delete, and change existing classes. Changes may add or remove fields and methods, replace existing ones, and change type signatures. Changes may occur at any level of the class hierarchy. To initialize new fields and update existing ones, Jvolve applies class and object transformer functions, the former for static fields and the latter for object instance fields. These features cover many updates seen in practice. Jvolve supports 20 of 22 updates to three open-source programs---Jetty web server, JavaEmailServer, and CrossFTP server---based on actual releases occurring over a one to two year period. This support is substantially more flexible than prior systems. Jvolve is safe. It relies on bytecode verification to statically type-check updated classes. To avoid dynamic type errors due to the timing of an update, Jvolve stops the executing threads at a DSU safe point and then applies the update. DSU safe points are a subset of VM safe points, where it is safe to perform garbage collection and thread scheduling. DSU safe points further restrict the methods that may be on each thread's stack, depending on the update. Restricted methods include updated methods for code consistency and safety, and user-specified methods for semantic safety. Jvolve installs return barriers and uses on-stack replacement to speed up reaching a safe point when necessary. While Jvolve does not guarantee that it will reach a DSU safe point, in our multithreaded benchmarks it almost always does. Jvolve includes a tool that automatically generates default object transformers which initialize new and changed fields to default values and retain values of unchanged fields in heap objects. If needed, programmers may customize the default transformers. Jvolve is the first dynamic updating system to extend the garbage collector to identify and transform all object instances of updated types. This dissertation introduces the concept of object-specific state transformers to repair application heap state for certain classes of bugs that corrupt part of the heap, and a novel methodology that employes dynamic analysis to automatically generate these transformers. Jvolve's eager object transformation design and implementation supports the widest class of updates to date. Finally, Jvolve is efficient. It imposes no overhead during steady-state execution. During an update, it imposes overheads to classloading and garbage collection. After an update, the adaptive compilation system will incrementally optimize the updated code in its usual fashion. Jvolve is the first full-featured dynamic updating system that imposes no steady-state overhead. In summary, Jvolve is the most-featured, most flexible, safest, and best-performing dynamic updating system for Java and marks a significant step towards practical support for dynamic updates in managed language virtual machines. / text

The daily use of Internet services in the most diverse human activities creates in users the expectation of high availability of these services. Many of them have database systems as essential building block. Moreover, those services are subject outcomes such as errors and aging. An error-free software or a non-aging software which does not need innovations is an utopia. Thus, software updating is a required task. Currently, software-updating mechanisms are based on two different solutions: (i) using of additional hardware, an expensive and complex solution, or (ii) service interruption, which is trivial but inefficient. In this work, we explore the application of Dynamic Software Update (DSU) techniques as an alternative to update a Data Base Management System (DBMS) without requiring any additional hardware or service unavailability. Our solution was developed in a hypothetical DBMS architecture with the support of a software component model. A prototype was developed in accordance with this model using FRACTAL. Experimental evaluation confirmed the functional viability of this approach. The implementation overhead in a controlled environment was about 30%, which is acceptable. / O uso cotidiano da Internet nas mais diversas atividades humanas acaba por criar nos usuários a expectativa de serviços disponíveis a qualquer momento. Muitos destes serviços tem os Sistemas Gerenciadores de Banco de Dados (SGBDs) como ferramenta básica e essencial. Além disso, esses softwares estão sujeitos a erros e envelhecimento. Um software livre de erros ou que não precise de inovações é uma utopia. Assim, é necessário que o software sofra atualizações. Atualmente, os mecanismos para atualização de software utilizam hardware adicional, uma solução mais cara e complexa, ou optam pela indisponibilição do serviço para os clientes (parada do sistema), que é solução trivial mas ainda eficiente. O que este trabalho traz é a aplicação de técnicas de Atualização Dinâmica de Software (ADS) como uma alternativa para atualizar um SGBD sem o uso de hardware adicional e a indisponibilização do sistema. Para tanto, propõe-se o desenvolvimento de um SGBD em uma arquitetura hipotética com o suporte de componentes de software. Criou-se um protótipo de acordo com a solução proposta, utilizando o modelo de componentes FRACTAL. A avaliação experimental confirmou a viabilidade funcional da solução e que a sobrecarga da implementação em um ambiente controlado foi de aproximadamente 30%. Esta sobrecarga é aceitável, uma vez que se obtem a atualização do SGBD sem a parada total do mesmo.