Estimating Discrete-Time Periodic Software Rejuvenation

Software faults should ideally have been removed during the debugging phase. Even if software may have been thoroughly tested, it still may have some design faults that are yet to be revealed. Such faults are called bohrbugs and may exist even in mature software such as commercial operating systems. Also, even mature software can be expected to have what are known as heisenbugs [11]. These are bugs in the software that are revealed only during specific collusions of events. For example, asequence of operations may leave the software in astate that results in an error on an operation executed next. Simply retrying afailed operation, or if the application process has crashed, restarting the process might resolve the problem. Another tyPe of fault observed in software systems is due to the phenomenon of resource exhaustion. Operating system resources such as swap space and free memory available are progressively depleted due to defects in software such as memory leaks and incomplete cleanup of resources after use. These faults may exist in the operating system, middleware and the application software. In fact, when software application executes continuously for long periods of time, some of the faults cause software to age due to the error conditions that accrue with time $\mathrm{a}\mathrm{n}\mathrm{d}/\mathrm{o}\mathrm{r}$ load. Software aging will affect the performance of the application and eventually cause it to fail [1, 4, 8, 16]. Software aging has also been observed in widely-used software like Internet Explorer, Netscape and xrn as well as commercial operating systems and middleware. Acomplementary approach to handle software aging and its related transient software failures, called software rejuvenation, are becoming popular [12]. Software rejuvenation is apreventive and proactive solution that is particularly useful for counteracting the phenomenon of software aging. It involves stopping the running software occasionally, cleaning its internal state and restarting it. Cleaning the internal state of asoftware might involve garbage collection, flushing operating system kernel tables, reinitializing internal data structures, and hardware reboot. Huang et al. [12] report the software aging phenomenon in real telecommunications billing application where over time the application experiences acrash or ahang failure, and propose to perform rejuvenation occasionally or periodically. More specifically, they consider the degradation as atwo step process. From the clean state the software system jumps into adegraded state from which two actions are possible: rejuvenation with return to the clean state or transition to the complete failure state. They model the four-state process as acontinuous-time Markov chain and derive the steady-state availability and the expected cost per unit time in the steady state. Avritzer and Weyuker [2] discuss aging in atelecommunication switching software where the effect manifests as gradual performance degradation. Garg et al. [9] introduce the idea of periodic rejuvenation (deterministic interval between successive rejuvenations) into the Huang et al. model [12] and represent the stochastic behavior by using aMarkov regenerative stochastic Petri net. Dohi et al. [5] extend the original Huang et al. model to semi-Markov models and develo$\mathrm{p}$ 数理解析研究所講究録 1306巻 2003年 152-161