Aging-related Bugs Research Articles

SGT: Aging-related bug prediction via semantic feature learning based on graph-transformer

Software aging, characterized by an increasing failure rate or performance decline in long-running software systems, poses significant risks including financial losses and potential harm to human life. This is primarily attributed to the accumulation of runtime errors, commonly referred to as aging-related bugs (ARBs). ARBP aims to detect and address ARBs before software release, optimizing testing resource allocation. However, ARBP’s effectiveness relies heavily on dataset quality. Prior research often relied on manually designed metrics that lack semantic features, resulting in low prediction accuracy. Some studies construct models to learn semantic features from source code, but typically focus on token-level features from abstract Syntax Trees, neglecting critical topological and functional connections. In this paper, we introduce the SGT model, an ARBP method based on Graph-Transformer. This model efficiently extracts semantic information and logical structures from source code, capturing data dependencies and program dependencies. We also propose sub-graph sampling based on node degree to reduce structural complexity and apply random oversampling to address class imbalance. Experiments on three projects demonstrate notable improvements. For instance, SGT achieved F1 scores of 0.726 and 0.706 on Linux and MySQL, respectively. Compared to ALW, SGT shows a 12.3% and 6.8% improvement on Linux and MySQL.

SMOTE-Based Homogeneous Prediction for Aging-Related Bugs in Cloud-Oriented Software

Software aging is the process caused by Aging-Related Bugs (ARBs) which leads to the depletion of resources and degradation of performance in the long run. ARBs are difficult to find and replicate in future studies as they are less in number, thus prediction of ARB is necessary to save cost and time in the testing phase. ARBs are present in low proportion as compared to non-ARBs known as the class Imbalance problem resulting in insufficient training dataset for prediction models. In this study, Synthetic Minority Oversampling Technique (SMOTE) is applied along with homogeneous cross-project ARB prediction to reduce the effect of imbalance problem in software. SMOTE is oversampling of the minority instances synthetically to balance the dataset and improve the capability of defect prediction models. Homogeneous cross-project prediction is implemented where the datasets are different but the distribution of metric sets of both training and testing datasets is similar. The experiment is conducted on five cloud-oriented software such as Cassandra, Hive, Storm, Hadoop HDFS and Hadoop Mapreduce. The novelty of this study is the combination of SMOTE and homogeneous cross-project defect prediction for ARBs in cloud-oriented software. The comparative analysis is also conducted to understand the difference between SMOTE and non-SMOTE results with the help of machine learning classifiers. The result conveys that SMOTE is an efficient method to address class imbalance problem in ARB prediction.

Predicting Aging-Related Bugs Using Network Analysis on Aging-Related Dependency Networks

Software aging, a phenomenon that exhibits an increasing failure rate or progressive performance degradation in long-running software systems, has caused serious cost damage or even loss of human lives. To aid aging-related bug (ARB, whose activation can result in software aging) detection and removal before software release, ARB prediction was proposed. Based on the prediction results, software teams can allocate limited testing resources to ARB-prone modules. Previous research has proposed several methods for both within-project and cross-project ARB prediction. However, they are based on the same set of metrics focusing on the contents of a single module, and only six metrics are aging-related. In this paper, we develop aging-related network measures by constructing an aging-related dependency network to model the flow of aging-related information in the software. Our evaluation on three commonly used open-source projects reveals that aging-related network measures show an inconsistent association with ARB-proneness in three projects, and the performance of aging-related network measures varies under different ARB prediction settings.

An empirical study of Aging Related Bug prediction using Cross Project in Cloud Oriented Software

Cloud oriented applications enable users to increase the scalability of computing infrastructure by using shared computer resources. These applications include the characteristics such as NoSQL database, BigData Analytics, distributed file system and MapReduce architecture which may face issues like software aging due to which ongoing system's performance decreases and failure rate increases. Aging Related Bugs (ARB) are bugs that are caused due to memory leakage, null pointer exception, resource depletion etc. in the ongoing system whose impact can be dangerous, so it’s better to predict them before releasing the software. Manual extraction of ARB reports are common but finding ARBs within thousand of bug reports is challenging. This is the first paper that presents the empirical study to automatically search aging related bug reports through SEARCH_KEYWORD algorithm and implement the ARB prediction in cross project for cloud oriented applications/softwares. To compare the efficacy of the prediction results, With-in Project Defect Prediction (WPDP) of ARBs is also performed. The work is divided in three phases: 1. ARB reports are extracted from the summary/description of bug in bug repository through automatic process. 2. Cross project bug prediction (CPDP) is performed to predict ARB due to limited availability of training data which is not implemented yet in cloud oriented softwares to the best of our knowledge. 3. Machine learning techniques are applied for ARB prediction to build fault prediction models. There is an imbalanced proportion between ARB-prone and ARB-free files, therefore Recall, FPR(False Positive Rate), Balance are used as major performance measures to predict ARBs. Kruskal Wallis Test and Friedman Test, are applied on the prediction results and it is proved that Naive Bayes performed significantly better than other classifiers. The results suggested that CPDP performed better than WPDP of ARBs using machine learning classifiers in cloud oriented datasets.

ARES: A Framework for Management of Aging and Rejuvenation in Softwarized Networks

The recent trend of network softwarization suggests a radical shift in the implementation of traditional network intelligence. In Software Defined Networking (SDN), for instance, the control plane functions of forwarding devices are outsourced to the controller. Softwarized network components are expected to provide uninterrupted service during long periods of time, which makes them prone to the effects of <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">software aging</i> , a phenomena that has been observed in operational software systems where the failure rate increases or the performance of the software degrades with the elapsed time since the last restart. The effects of software aging in operational networks are typically mitigated by <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">software rejuvenation</i> , i.e., planned restarts cleaning the internal system state in order to prevent or postpone aging-related failures. This article presents <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">ARES</i> , a three-step methodological framework for the management of the effects of software aging in softwarized networks, applied to the case study of open source SDN orchestration platforms. Using ARES, we demonstrate that software aging is a systematic problem that cannot be neglected in network orchestration systems. It stems not only from aging-related bugs and natural aging due to fragmentation, but also from design choices, e.g., when implementing distributed systems. Measurements for Open Network Operating System (ONOS) and OpenDaylight (ODL) demonstrate how “simple” and common networking tasks let network performance degrade rapidly and even lead to crashes: for instance, adding and removing 300 intents per second in ONOS significantly increases the response time by 50% per day and depletes the memory at the rate of 18GB per day. Moreover, we demonstrate a first rejuvenation approach that can mitigate the effects of aging in ONOS.

Generative Adversarial Networks-Based Imbalance Learning in Software Aging-Related Bug Prediction

Software aging refers to a problem of performance decay in the software systems, which are running for a long period. The primary cause of this phenomenon is the accumulation of run-time errors in the software, which are also known as aging-related bugs (ARBs). Many efforts have been reported earlier to predict the origin of ARBs in the software so that these bugs can be identified and fixed during testing. Imbalanced dataset, where the representation of ARBs patterns is very less as compared to the representation of the non-ARBs pattern significantly hinders the performance of the ARBs prediction models. Therefore, in this article, we present an oversampling approach, generative adversarial networks-based synthetic data generation-based ARBs prediction models. The approach uses generative adversarial networks to generate synthetic samples for the ARBs patterns in the given datasets implicitly and build the prediction models on the processed datasets. To validate the performance of the presented approach, we perform an experimental study for the seven ARBs datasets collected from the public repository and use various performance measures to evaluate the results. The experimental results showed that the presented approach led to the improved performance of prediction models for the ARBs prediction as compared to the other state-of-the-art models.

Invalid bug reports complicate the software aging situation

Symptoms of software aging include performance degradation and failure occurrence increasing when software systems run for a period of time. Therefore, software aging is closely related to system performance. Understanding and analyzing performance issues in the software system is critical to mastering software aging information. Instead of focusing on normal valid bug reports (VBRs), this paper advocates the usage of invalid bug reports (IBRs) to capture software aging signals. We use performance bugs that are highly related to software aging as an example to construct a binary classification model for bug report classification. We conduct a rigorous evaluation of the constructed models via different performance measures (i.e., recall, precision, F1-score, AUC). Then, the model is used to predict the performance bug reports (PBRs) in IBRs, and a manual analysis of the prediction results is conducted to identify aging-related bug reports (ABRs). The final results show that the ratio of PBRs in IBRs ranges from 4.9 to 42.18% for the two real open-source projects HDFS and HBase when considering five different classifiers. Among these five classifiers, Support Vector Machine (SVM) classifier can achieve the best performance. The ratios of PBRs in IBRs by using this classifier are 11.1% and 15.35% for these two datasets and the performances in terms of F1-score are 85% and 74%. Further analysis of the predicted PBRs of IBRs in the project HDFS is conducted through a manual user case study; some surprising findings revealing the relationship between IBRs, PBRs, and ABRs are presented: (1) Around 50% of the PBRs in IBRs are related to software aging; (2) components that undertake major tasks are more prone to aging problems; (3) more than 50% ARBs lead to timeout, 33% ARBs are caused by improper control of memory or threats, and 29% ARBs are caused by inappropriate management of file operation or disk usage; (4) hard to reproduce is the major reason that ARBs are usually closed as invalid because many aging-related bugs would temporarily disappear by restarting the system.

An empirical study of factors affecting cross-project aging-related bug prediction with TLAP

Software aging is a phenomenon in which long-running software systems show an increasing failure rate and/or progressive performance degradation. Due to their nature, Aging-Related Bugs (ARBs) are hard to discover during software testing and are also challenging to reproduce. Therefore, automatically predicting ARBs before software release can help developers reduce ARB impact or avoid ARBs. Many bug prediction approaches have been proposed, and most of them show effectiveness in within-project prediction settings. However, due to the low presence and reproducing difficulty of ARBs, it is usually hard to collect sufficient training data to build an accurate prediction model. A recent work proposed a method named Transfer Learning based Aging-related bug Prediction (TLAP) for performing cross-project ARB prediction. Although this method considerably improves cross-project ARB prediction performance, it has been observed that its prediction result is affected by several key factors, such as the normalization methods, kernel functions, and machine learning classifiers. Therefore, this paper presents the first empirical study to examine the impact of these factors on the effectiveness of cross-project ARB prediction in terms of single-factor pattern, bigram pattern, and triplet pattern and validates the results with the Scott-Knott test technique. We find that kernel functions and classifiers are key factors affecting the effectiveness of cross-project ARB prediction, while normalization methods do not show statistical influence. In addition, the order of values in three single-factor patterns is maintained in three bigram patterns and one triplet pattern to a large extent. Similarly, the order of values in the three bigram patterns is also maintained in the triplet pattern.

Studying Aging-Related Bug Prediction Using Cross-Project Models

In long running systems, software tends to encounter performance degradation and increasing failure rate during execution. This phenomenon has been named software aging, which is caused by aging-related bugs (ARBs). Testing resource allocation can be optimized by identifying ARB-prone modules with ARB prediction. However, due to the low presence and reproducing difficulty of ARBs, it is usually hard to collect sufficient training data to carry out within-project ARB prediction. In this paper, we propose an approach named transfer learning based aging-related bug prediction (TLAP) to perform cross-project ARB prediction. TLAP first takes advantage of transfer learning to reduce distribution difference between training and testing project. Then, class imbalance learning is conducted to mitigate the severe class imbalance between ARB-prone and ARB-free modules. Finally, machine learning methods are used to handle bug prediction tasks. The effectiveness of this approach is validated and evaluated by nine groups of experiments on real software systems. Major conclusions from the experiments include the following: first, TLAP improves cross-project ARB prediction on average compared with traditional machine learning methods; second, utilizing information from multiple-projects can further improve the prediction performance on average. In the best case, it outperforms within-project prediction; third, the number of ARB-prone files and distribution similarity can influence TLAP performance.

A transient interval reliability analysis for software rejuvenation models with phase expansion

The phenomenon of software aging refers to the continuing degradation of software system performance with the operation time and is usually caused by the aging-related bugs such as the memory leak and the accumulation of round-off errors. Software rejuvenation acts as one of the proactive fault management techniques against the software aging. In this paper, we evaluate the interval reliability for two basic stochastic models with periodic software rejuvenation by Garg et al. (1995) and Suzuki et al. (2002a, b). The interval reliability is one of the most generalized dependability measures that involve commonly used reliability function and steady-state availability as the special cases, and is helpful for the system design during a fixed mission period. From the mathematical point of view, the interval reliability for the software rejuvenation models leads to the transient analysis. We focus on the phase expansion approach for solving the transient solutions for the basic software rejuvenation models. The phase expansion is an approximate technique that replaces arbitrary probability distributions by the phase-type (PH) distributions. Benefiting from the phase expansion, we can numerically derive the transient interval reliability for two software rejuvenation models. In numerical examples, we discuss the accuracy of the phase expansion and also reveal quantitative properties of the interval reliability measures.

Software Health Measurement Method Based on Aging-related Bugs

Aging-related bugs can lead to software aging, whose performance is the slow response on software system though the software does not crash. This paper aims to propose the measurement method of software health to quantitatively show the impact of aging-related bugs on software. The effect of the bugs and the elements were analyzed. The Gaussian mixture model was developed to measure the degree of software health, which provide the basis for the software failure alarming and failure prediction. Finally, the details of the method were shown by a case study on Hadoop Distributed File System.

Optimised Migrate Virtual Machine Rejuvenation

Server virtualization is an essential component in virtualized software infrastructure such as cloud computing. Virtual machines are generated through a software called virtual machine monitor (VMM) running on physical servers. The risks of software aging caused by aging-related bugs affect both VM and VMM. As a result, service reliability degrades may generate huge financial losses to companies. This paper presents an analytic model using stochastic reward nets for timebased rejuvenation techniques of VMM and VM. We propose to manipulate the VM behavior while the VMM rejuvenation is according to the load on the system. Using a previous Petri net model of virtualized server, we performed an algorithm in order to optimize rejuvenation technique and achieve high availability. So we perform Migrate-VM rejuvenation or Warm-VM rejuvenation while there are current jobs in the system. Although Migrate-VM rejuvenation is better than Warm-VM rejuvenation in steady state availability, it can’t be always performed as it depends on the capacity of the other host. When the queue is empty and the virtual machine has no current jobs to serve, we propose to combine both VMM rejuvenation and VM rejuvenation. We show that the proposed technique can enhance the availability of VMs.

A comprehensive availability modeling and analysis of a virtualized servers system using stochastic reward nets.

It is important to assess availability of virtualized systems in IT business infrastructures. Previous work on availability modeling and analysis of the virtualized systems used a simplified configuration and assumption in which only one virtual machine (VM) runs on a virtual machine monitor (VMM) hosted on a physical server. In this paper, we show a comprehensive availability model using stochastic reward nets (SRN). The model takes into account (i) the detailed failures and recovery behaviors of multiple VMs, (ii) various other failure modes and corresponding recovery behaviors (e.g., hardware faults, failure and recovery due to Mandelbugs and aging-related bugs), and (iii) dependency between different subcomponents (e.g., between physical host failure and VMM, etc.) in a virtualized servers system. We also show numerical analysis on steady state availability, downtime in hours per year, transaction loss, and sensitivity analysis. This model provides a new finding on how to increase system availability by combining both software rejuvenations at VM and VMM in a wise manner.

Predicting aging-related bugs using software complexity metrics

Long-running software systems tend to show degraded performance and an increased failure occurrence rate. This problem, known as Software Aging, which is typically related to the runtime accumulation of error conditions, is caused by the activation of the so-called Aging-Related Bugs (ARBs). This paper aims to predict the location of Aging-Related Bugs in complex software systems, so as to aid their identification during testing. First, we carried out a bug data analysis on three large software projects in order to collect data about ARBs. Then, a set of software complexity metrics were selected and extracted from the three projects. Finally, by using such metrics as predictor variables and machine learning algorithms, we built fault prediction models that can be used to predict which source code files are more prone to Aging-Related Bugs.

Software fault mitigation and availability assurance techniques

Companies are expected to keep their systems up and running and make data continuously available. Several recent studies have established that most system outages are due to software faults. In this paper, we discuss availability aspects of large software-based systems. We begin by classifying software faults into Bohrbugs and Mandelbugs, and identify aging-related bugs as a subtype of the latter. We then examine mitigation methods for Mandelbugs in general and aging-related bugs in particular. Finally, we discuss techniques for the quantitative availability assurance for such systems.

Fighting bugs: remove, retry, replicate, and rejuvenate

Even if software developers don't fully understand the faults or know their location in the code, software rejuvenation can help avoid failures in the presence of aging-related bugs. This is good news because reproducing and isolating an aging-related bug can be quite involved, similar to other Mandelbugs. Moreover, monitoring for signs of software aging can even help detect software faults that were missed during the development and testing phases. If, on the other hand, a developer can detect a specific aging-related bug in the code, fixing it and distributing a software update might be worthwhile. In the case of the Patriot missile-defense system, a modified version of the software was indeed prepared and deployed to users. It arrived at Dhahran on 26 February 1991 - a day after the fatal incident.