Existing Fault Localization Research Articles

Faults locating of power distribution systems based on successive PSO-GA algorithm

As the terminal of the power system, the distribution network is the main area where failures occur. In addition, with the integration of distributed generation, the traditional distribution network becomes more complex, rendering the conventional fault location algorithms based on a single power supply obsolete. Therefore, it is necessary to seek a new algorithm to locate the fault of the distributed power distribution network. In existing fault localization algorithms for distribution networks, since there are only two states of line faults, which can usually be represented by 0 and 1, most algorithms use discrete algorithms with this characteristic for iterative optimization. Therefore, this paper combines the advantages of the particle swarm algorithm and genetic algorithm and uses continuous real numbers for iteration to construct a successive particle swarm genetic algorithm (SPSO-GA) different from previous algorithms. The accuracy, speed, and fault tolerance of SPSO-GA, discrete particle swarm Genetic algorithm, and artificial fish swarm algorithm are compared in an IEEE33-node distribution network with the distributed power supply. The simulation results show that the SPSO-GA algorithm has high optimization accuracy and stability for single, double, or triple faults. Furthermore, SPSO-GA has a rapid convergence velocity, requires fewer particles, and can locate the fault segment accurately for the distribution network containing distorted information.

Enhanced fault localization in multi-terminal transmission lines using novel machine learning

Accurate fault location on transmission lines is paramount for ensuring the reliable and efficient operation of the electricity grid, which underpins every aspect of modern society. Existing fault localization methods for transmission lines often face shortcomings, particularly in scenarios involving multi-terminal transmission lines, where complexities arise due to dispersed generations and intricate network configurations. Traditional approaches may struggle to provide accurate fault localization, impacting the reliability and efficiency of the electricity grid. Research provide a unique fault localization technique in this article depends on Phasor Measurement Units (PMUs) and Bidirectional Gradient Boost Random Forest (BDGB-RF) machine learning technique to address these challenges. The proposed method offers several advantages over traditional methods, including enhanced accuracy and efficiency. By leveraging PMU data and BDGB-RF, the method provides a two-phase fault localization strategy, incorporating fault line selection based on nodal current imbalance and subsequent fault distance determination. Simulation results demonstrate the effectiveness of the proposed approach, achieving up to 97% accuracy in the majority of studied scenarios, even under different tapping configurations. The adoption of this approach could significantly impact the practices of experts in the field, facilitating more reliable fault detection and localization in complex transmission line networks. This, in turn, can contribute to the resilience and stability of power systems, ultimately improving grid reliability and minimizing downtime.

Model-domain failing test augmentation with Generative Adversarial Networks

It is undoubtedly that test suites are crucial for fault localization techniques. Through the running of a single test case in the test suite, a fault localization technology is able to obtain the dynamic coverage information of the statements, which is a vector and could be analyzed to identify the corresponding coefficients between statements and program failures. This vector is commonly referred to as a model domain test sample. There are two types of model domain test samples: passing ones and failing ones. However, the number of passing test samples often far exceeds the number of failing ones, which undoubtedly causes the asymmetry phenomenon. Previous studies have proved that the imbalance of model domain test samples may hamper the effectiveness of fault localization techniques. In practice, it is difficult to create failing test cases in input domain. With the rapid development of deep learning techniques, Generative Adversarial Networks (GAN) have achieved promising results in many fields, which may bring a new perspective for augmenting model domain failing test samples. Thus, we try to provide a new method named MAG: Model-domain failing test Augmentation with Generative Adversarial Networks. MAG first constructs a Generative Adversarial Network, and then generates vectors with the abstract representation of execution information as input. At last, MAG utilizes influential global and local contexts to enhance the generated vectors, and to formulate model domain test samples with failing labels. MAG augments model domain failing test samples. Different from traditional methods of generating test cases directly from input domain, MAG seeks to augment failing test samples of model domain, which could improve the effectiveness of existing fault localization techniques. Experimental results illustrate that MAG significantly improves the effectiveness of 13 typical fault localization approaches and is better than two representative data optimization techniques.

Software multiple-fault localization using particle swarm optimization via genetic operation

Recently, spectrum-based fault localization approaches have been widely used for its fast and perform well for programs with only one fault.However, most of the existing methods do not consider the fact that the programs tend to have multiple faults. To address the above issue, we propose a Particle Swarm Optimization with genetic operation based Multiple-Fault Localization (PSOMFL). Our method models the software multiple-fault localization process as a search process for the particle swarm algorithm, which can quickly find the optimal solution in the multi-dimensional hyper-volume, and finally analyzes the optimal solution set to obtain the locations of multiple faults. We have implemented a prototype and conducted several experiments to compare PSOMFL against the existing fault localization approaches. The experimental results show that PSOMFL outperforms the compared methods and can reduce the costs by 5%-25% on average.

An Empirical Study of Boosting Spectrum-Based Fault Localization via PageRank

Manual debugging is notoriously tedious and time-consuming. Therefore, various automated fault localization techniques have been proposed to help with manual debugging. Among the existing fault localization techniques, spectrum-based fault localization (SBFL) is one of the most widely studied techniques due to being lightweight. The focus of the existing SBFL techniques is to consider how to differentiate program entities (i.e., one dimension in program spectra); indeed, this focus is aligned with the ultimate goal of finding the faulty lines of code. Our key insight is to enhance the existing SBFL techniques by additionally considering how to differentiate tests (i.e., the other dimension in program spectra), which, to the best of our knowledge, has not been studied in prior work. We present our basic approach, PRFL, a lightweight technique that boosts SBFL by differentiating tests using PageRank algorithm. Specifically, given the original program spectrum information, PRFL uses PageRank to recompute the spectrum by considering the contributions of different tests. Next, traditional SBFL techniques are applied on the recomputed spectrum to achieve more effective fault localization. On top of PRFL, we explore PRFL+ and PRFL <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">MA</sub> , two variants which extend PRFL by optimizing its components and integrating Method-level Aggregation technique, respectively. Though being simple and lightweight, PRFL has been demonstrated to outperform state-of-the-art SBFL techniques significantly (e.g., ranking 39.2% / 82.3% more real/artificial faults at Top-1 compared with the most effective traditional SBFL technique) with low overhead (e.g., around 6 minutes average extra overhead on real faults) on 395 real faults from 6 Defects4J projects and 96925 artificial (i.e., mutation) faults from 240 GitHub projects. To further validate PRFL's effectiveness, we compare PRFL with multiple recent proposed fault localization techniques (e.g., Multric, Metallaxis and MBFL-hybrid-avg), and the experimental results show that PRFL outperforms them as well. Furthermore, we study the performance of PRFL <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">MA</sub> , and the experimental results present it can locate 137 real faults (73.4% / 24.5% more compared with the most effective SBFL/PRFL technique) and 35058 artificial faults (159.6% / 28.1% more than SBFL/PRFL technique) at Top-1. At last, we study the generalizability of PRFL on another benchmark, Bugs.jar, and the result shows PRFL can help locate around 30 percent more faults at Top 1.

MuSim: Mutation-based Fault Localization Using Test Case Proximity

Fault localization techniques aim to localize faulty statements using the information gathered from both passed and failed test cases. We present a mutation-based fault localization technique called MuSim. MuSim identifies the faulty statement based on its computed proximity to different mutants. We study the performance of MuSim by using four different similarity metrics. To satisfactorily measure the effectiveness of our proposed approach, we present a new evaluation metric called Mut_Score. Based on this metric, on an average, MuSim is 33.21% more effective than existing fault localization techniques such as DStar, Tarantula, Crosstab, Ochiai.

Fault Localization With Weighted Test Model in Model Transformations

Model transformations and model-driven engineering (MDE) have been applied widely in service-oriented architecture based information systems. To support the development of such a service-oriented information system, it is necessary to guarantee the quality of model transformations. With the increasing complexity and scale of model transformations, debugging of model transformations becomes more and more time-consuming and difficult, there is an increasing need to rely on efficient and accurate fault localization approaches to help with debugging. Among the existing fault localization approaches, the spectrum-based fault localization (SBFL), as a dynamic analysis method, mainly used the coverage information and execution results of the rules of model transformation to estimate the probability of each rule may be faulty. However, there are many false-positive and false-negative results in the rule coverage information, the accuracy of the SBFL is not ideal, so we consider mining the impact of covered range in different test models to further improve the effectiveness of fault localization. In this paper, we propose an optimized strategy of fault localization based on the impact of the test model, according to the covered range of test models, weight values are assigned to different test models, and the statistical coverage information of rules are weighted and adjusted accordingly. We compare the proposed approach with the SBFL, the experimental results show that under the same techniques for computing the suspiciousness, our approach can help locate around 26% more faulty rules in the ranking Top-1 of the suspicious list than the SBFL, the effectiveness of fault localization techniques can be improved by 50.42% in the best case and 8.9% in the average case.

Software fault localization using BP neural network based on function and branch coverage

Software failure is inevitable with the increase in scale and complexity of the software. Existing fault localization techniques based on neural networks take statement coverage information and test case execution results into account to train the network. In this paper, we propose an effective approach for fault localization based on back-propagation neural network which utilizes branch and function coverage information along with test case execution results to train the network. We investigated our approach using Siemens suite. Our experimental result shows that our proposed approach performs on average 23.50–44.27% better than existing fault localization techniques.

RFL: Robust fault localization on unreliable communication channels

The current Internet is vulnerable to various attacks, e.g., source spoofing and flow hijacking attacks, which are incurred by misconfigurations or attacks. Either users or network operators are unable to easily localize these faults. Existing fault localization mechanisms can detect such attacks under an assumption that localization is performed upon reliable communication channels. Unfortunately, the assumption does not always hold. The forwarding paths of localization are not always reliable. Packets are usually dropped for some reasons. In particular, adversaries can interfere with fault localization by maliciously dropping packets. In this paper, we relax the assumption and propose a robust data-plane fault localization protocol named RFL that can localize faults and achieve source authenticity and path compliance even if communication channels in the network are not reliable. RFL samples and verifies packets in each network entity so that the packet source can efficiently localize faults of packet forwarding by verifying the sampled packets. By leveraging packet acknowledgment, packet sampling based fault localization is not impacted by packet loss in the communication channels. In particular, RFL leverages a symmetric key distribution scheme to implement robust key distribution among different entities, which ensures that packet sources can always correctly fresh their keys to perform correct localization. Our security and theoretical analysis demonstrates the robustness of RFL protocol. We implement the RFL prototype on Click routers. The experiment results with the prototype demonstrate that RFL achieves more than 99.5% localization accuracy while incurring only 10% throughput degradation.

A Community-Based Fault Isolation Approach for Effective Simultaneous Localization of Faults

During program testing, software programs may be discovered to contain multiple faults. Multiple faults in a program may reduce the effectiveness of the existing fault localization techniques due to the complex relationship between faults and failures in the presence of multiple faults. In an ideal case, faults are isolated into fault-focused clusters, each targeting a single fault for developers to localize them simultaneously in parallel. However, the relationship between faults and failures is not easily identified and depends solely on the accuracy of clustering, such as existing clustering algorithms are not able to isolate failed tests to their causative faults effectively which hinder localization effectiveness. This paper proposes a new approach that makes use of a divisive network community clustering algorithm to isolate faults into separate fault-focused communities that target a single fault each. A community weighting and a selection mechanism that aids in prioritizing highly important fault-focused communities to the available developers to debug the faults simultaneously in parallel is also proposed. The approach is evaluated on eight subject programs ranging from medium-sized to large-sized programs (tcas, replace, gzip, sed, flex, grep, make, and ant). Overall, 540 multiple-fault versions of these programs were generated with 2-5 faulty versions. The experimental results have demonstrated that the proposed approach performs significantly better in terms of localization effectiveness in comparison with two other parallel debugging approaches for locating multiple faults in parallel.

Localizing multiple software faults based on evolution algorithm

During software debugging, a significant amount of effort is required for programmers to identify the root cause of manifested failures. Various spectrum-based fault localization techniques have been proposed to automate the procedure. However, most of the existing fault localization approaches do not consider the fact that programs tend to have multiple faults. Considering faults in isolation results in less accurate analysis. In this paper, we propose a flexible framework called FSMFL for localizing multiple faults simultaneously based on genetic algorithms with simulated annealing. FSMFL can be easily extended by different fitness functions for the purpose of localizing multiple faults simultaneously. We have implemented a prototype and conducted extensive experiments to compare FSMFL against existing spectrum based fault localization approaches. The experimental results show that FSMFL is competitive in single-fault localization and superior in multi-fault localization.

Simultaneous Localization of Software Faults Based on Complex Network Theory

Effective debugging is necessary for producing high quality and reliable software. Fault localization plays a vital role in the debugging process. However, fault localization is the most tedious and expensive activity in program debugging, as such, effective fault localization techniques that can identify the exact location of faults is eminent. Despite various fault localization techniques proposed, their application in multiple-fault programs is limited. The presence of multiple faults in a program reduces the efficacy of the existing fault localization techniques to locate faults effectively due to fault interference. Moreover, most of these techniques are unable to localize faults simultaneously. This has led researchers to adopt alternative approaches, such as one-fault-at-a-time debugging and parallel debugging. In this paper, we propose a novel fault localization technique based on complex network theory (FLCN) to improve localization effectiveness in programs with single-fault and multiple-fault and to aid developers to localize multiple faults simultaneously in a single diagnosis rank list. The proposed technique ranks faulty statements based on their behavioral abnormalities and distance between faulty statements in both passed and failed test executions. Two graph-based centrality measures are adopted for fault diagnosis, namely, degree centrality and closeness centrality and a new ranking formula is proposed. FLCN is evaluated across 14 subjects with both single-fault and multiple-fault programs. Our experimental results show that FLCN is more effective at locating faults when compared with existing state-of-the-art fault localization techniques with improvement of fault localization effectiveness in both single-fault and multiple-fault programs.

Fault Localizations Through Feature Selections

We introduce a novel application of feature ranking methods to the fault localization problem. We envision the problem of localizing causes of failures as instances of ranking program’s elements where elements are conceptualized as features. In this paper, we define features as program’s statements. However, in its fine-grained definition, the idea of program’s features can refer to any traits of programs. This paper proposes feature ranking-based algorithms. The algorithms analyze execution traces of both passing and failing test cases, and extract the bug signatures from the failing test cases. The proposed procedure extracts possible combinations of program’s elements when executed together from bug signatures. The feature ranking-based algorithms then order statements according to the suspiciousness of the combinations. When viewed as sequences, the combination of program’s elements produced and traced in bug signatures can be utilized to reason about the common longest subsequence. The common longest subsequence of bug signatures represents the common statements executed by all failing test cases and thus provides a means for identifying statements that contain possible faults. Our evaluation indicates that the proposed feature-based fault localization outperforms existing fault localization ranking schemes.

Diversity maximization speedup for localizing faults in single-fault and multi-fault programs

Fault localization is useful for reducing debugging effort. Such techniques require test cases with oracles, which can determine whether a program behaves correctly for every test input. Although most fault localization techniques can localize faults relatively accurately even with a small number of test cases, choosing the right test cases and creating oracles for them are not easy. Test oracle creation is expensive because it can take much manual labeling effort (i.e., effort needed to decide whether the test cases pass or fail). Given a number of test cases to be executed, it is challenging to minimize the number of test cases requiring manual labeling and in the meantime achieve good fault localization accuracy. To address this challenge, this paper presents a novel test case selection strategy based on Diversity Maximization Speedup (Dms). Dms orders a set of unlabeled test cases in a way that maximizes the effectiveness of a fault localization technique. Developers are only expected to label a much smaller number of test cases along this ordering to achieve good fault localization results. We evaluate the performance of Dms on 2 different types of programs, single-fault and multi-fault programs. Our experiments with 411 faults from the Software-artifact Infrastructure Repository show (1) that Dms can help existing fault localization techniques to achieve comparable accuracy with on average 67 and 6 % fewer labeled test cases than previously best test case prioritization techniques for single-fault and multi-fault programs, and (2) that given a labeling budget (i.e., a fixed number of labeled test cases), Dms can help existing fault localization techniques reduce their debugging cost (in terms of the amount of code needed to be inspected to locate faults). We conduct hypothesis test and show that the saving of the debugging cost we achieve for the real C programs are statistically significant.

Concurrency bug localization using shared memory access pairs

Non-determinism in concurrent programs makes their debugging much more challenging than that in sequential programs. To mitigate such difficulties, we propose a new technique to automatically locate buggy shared memory accesses that triggered concurrency bugs. Compared to existing fault localization techniques that are based on empirical statistical approaches, this technique has two advantages. First, as long as enough successful runs of a concurrent program are collected, the proposed technique can locate buggy memory accesses to the shared data even with only one single failed run captured, as opposed to the need of capturing multiple failed runs in other statistical approaches. Second, the proposed technique is more precise because it considers memory accesses in those failed runs that terminate prematurely.

HSFal: Effective fault localization using hybrid spectrum of full slices and execution slices

Most of the existing fault localization approaches use execution coverage of test cases to isolate the suspicious codes that likely contain faults. Program slicing can extract the dependencies of program entities with respect to a specific criterion. Therefore this technique is expected to have a beneficial effect on fault localization. In this paper, we propose a novel approach using a hybrid spectrum of full slices and execution slices to improve the effectiveness of fault localization. In particular, our approach firstly computes full slices of failed test cases and execution slices of passed test cases respectively. Secondly it constructs the hybrid spectrum by intersecting full slices and execution slices. Finally it computes the suspiciousness of each statement in the hybrid slice spectrum and generates a fault location report with descending suspiciousness of each statement. We also implement our proposed approach in our prototype tool HSFal by Java programming language. To verify the effectiveness of our approach, we performed an empirical study by the prototype on several widely used open source programs. Our approach is compared with eight representative coverage-based and slice-based fault localization approaches. Final experimental results show that our proposed approach is more effective in fault localization than other compared approaches, and can reduce almost 2.98–31.79% of the average cost of examined code significantly.

BPELDebugger: An effective BPEL-specific fault localization framework

ContextBusiness Process Execution Language (BPEL) is a widely recognized executable service composition language, which is significantly different from typical programming languages in both syntax and semantics, and especially shorter in program scale. How to effectively locate faults in BPEL programs is an open and challenging problem. ObjectiveIn this paper, we propose a fault localization framework for BPEL programs. MethodBased on BPEL program characteristics, we propose two fault localization guidelines to locate the integration and interaction faults in BPEL programs. Our framework formulates the BPEL fault localization problem using the popular fault localization problem settings, and synthesizes BPEL-specific fault localization techniques by reuse of existing fault localization formulas. We use two realistic BPEL programs and three existing fault localization formulas to evaluate the feasibility and effectiveness of the proposed fault localization framework and guidelines. ResultExperiment results show that faults can be located with the fewest code examining efforts. That is, the fault-relevant basic block is assigned the highest suspiciousness score by our fault localization method. The experiment results also show that with the use of the proposed fault localization guidelines, the code examining efforts to locate faults are extraordinarily reduced. ConclusionWe conclude that the proposed framework is feasible in synthesizing effective fault localization techniques, and our fault localization guidelines are very effective to enhance existing fault localization techniques in locating faults in BPEL programs.

Focus section on program debugging

Focus section on program debugging

Using temporal correlation for fault localization in dynamically changing networks

AbstractA mobile ad hoc network creates a dynamic environment where node mobility can cause periodic changes in routes. Most existing fault localization algorithms assume availability of a complete and/or deterministic dependency model. Such assumptions cannot be made in the dynamically changing networks. This paper is aimed at developing a fault diagnosis architecture and algorithm to address the issue of dynamically changing dependencies in networks. We propose an architecture to capture the changes in dependencies and introduce a temporal correlation algorithm to perform fault diagnosis with the dynamically changing dependency information. We present an experimental evaluation of our work through simulation results using Qualnet. Copyright © 2007 John Wiley &amp; Sons, Ltd.