Determination of Safe regions in Optimized Dynamically Updatable Programs
Abhirup Ghosh · 2011
Every software needs to be updated either to fix bugs or to add new features. To update a running system, developers typically shut down the system for a while, apply the patch and then resume execution. However, many continuously running system cannot afford to halt or would prefer not to. One of the most convenient solutions to this problem is dynamic software update where the program is updated while the program is in execution the running program is stopped at program point p, then the program is updated to new version and after that execution resumes from p onwards. p should be a safe point to have the dynamic update safe. Till date, many dynamic updating systems have been developed like Ginseng, JVolve etc. None of the present literature has defined update safety in dynamically updatable programs. They have concentrated on type safety. We would define update safety in this report. Also, none of these works considered program optimization issues at the time of determining safe points. However, both the old version and new version codes are optimized by the compiler, so update to old version code may enable some optimization opportunities that were not possible otherwise or it may disable some previously performed optimizations. Therefore, not only the updates but also the optimizations and de-optimizations resulting from the updates change the code. In this report, we present a methodology to determine safe points in a program considering both updates and enabling and disabling of optimizations by the updates. We have implemented a system in LLVM to determine the safe regions in a program considering program optimizations. Our system can be integrated with any dynamic update system.