Interactive Software and Hardware Faults Diagnosis Based on Negative Selection Algorithm

A significant issue in fault injection experiments is that the injected faults are representative of software faults observed in the field. Another important issue is the time used, as we want experiments to be conducted without excessive time spent waiting for the consequences of a fault. An approach to accelerate the failure process would be to inject errors instead of faults, but this would require a mapping between representative software faults and injectable errors. Furthermore, it must be assured that the injected errors emulate software faults and not hardware faults. These issues were addressed in a study of software faults encountered in one release of a large IBM operating system product. The key results are: A general procedure that uses field data to generate a set of injectable errors, in which each error is defined by: error type, error location and injection condition. The procedure assures that the injected errors emulate software faults and not hardware faults. The faults are uniformly distributed (1.37 fault per module) over the affected modules. The distribution of error categories in the IBM operating system and the distribution of errors in the Tandem Guardian90 operating system reported previously were compared and found to be similar. This result adds a flavor of generality to the field data presented in the current paper.

A functional decomposition method for reliability analysis, based on the specific characteristics of real-time systems, is proposed. The system under scrutiny is decomposed into hardware modules and software tasks. The hardware structure and fault occurrence process are captured by a continuous-time, discrete-state Markov model. The software structure and fault/error handling process are described by several discrete-time, discrete-state Markov chains. Eventually, a reduced Markov model, which accounts for system hardware and software structure and fault occurrence and fault/error handling processes, is generated. Closed form solutions are derived for time dependent and steady state probabilities, taking into consideration the weights of permanent and transient fault classes. Failure rates and coverage probabilities are the input parameters of the model. Failure rates are provided by reliability handbooks or circuit life testing. Fault injection is usually used for deriving coverage probabilities. A fault injection simulation algorithm, based on functional decomposition, is described and the achievable simulation time savings are evaluated. The main advantages of the proposed modeling approach are: functional decomposition closely follows the hardware and software structure of the real system. This simplifies both the evaluation of the model input parameters and model validation; closed form solutions overcomes numerical problems, e.g. largeness and stiffness, typically encountered when Markov models are employed for reliability analysis; and considerable savings, in terns of simulation time, are achieved.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Real-time software is becoming more prevalent in avionics systems such as unmanned aerial vehicles and spacecrafts. More often, these systems operate with limited human interaction or an increased latency in human response. Therefore, these systems require autonomous fault detection and a repair mechanism to respond to off nominal conditions that could arise. In order to prevent a hazard, these systems require assurance that they will operate in a safe manner while successfully completing a mission. Assurance, as a software engineering activity involves the reduction of risk, and inversely, an increase in confidence in a software system. In the context of fault management, this becomes a question of increasing confidence that a software system can detect and respond to the offnominal conditions occur. This activity is not always straight forward as off-nominal conditions in complex real-time systems do not always manifest as singular events, but rather as a combination of symptoms. Furthermore, for fault management assurance to be useful it needs to be rigorous. Therefore, the approach needs to be supported by a standard, repeatable framework. The foundation for this framework is in the ability to model the fault management system integrated in the hardware and software avionics real-time system. Models can assist in assuring both functional and quality attribute requirements such as reliability. The Architecture Analysis and Design Language (AADL) is a Society of Automotive Engineers (SAE) standard notation (AS5506/1) for the modeling and analysis of real-time systems. AADL has been extended to model fault management behavior through the AADL Error Annex, also an SAE standard. At its core, the AADL Error Annex provides rules for how software and hardware components are allowed to propagate an error across the avionics real-time system modeled in AADL. Because a standard notation is being used, there is intrinsic confidence to the approach. This paper will explore how the assurance of software fault management can be applied in practice. First, it is important to briefly review AADL and the AADL Error Annex as well as common terminology related to software fault management. Next, the application of software fault management assurance will be discussed. The first step in this application is to understand the very basic (atomic) hardware and software faults that occur at the component level. This information can be collected in the form of a failure modes and effects analysis (FMEA). An analysis is required in order to evaluate the ability of the software fault management system to, at the very least, detect the symptoms. This analysis answers two fundamental questions. First, to what degree are faults visible to the avionics software? Second, to what degree does the avionics software handle these faults? This paper presents an example to demonstrate the assurance of software fault management. The software fault management assurance framework proposed in this paper utilizes a standard notation, coupled with a formal mechanism for modeling faults. This provides a rigorous foundation for analysis on the avionics software real-time system in a repeatable manner. Therefore a model based assurance activity of a software fault management system can successfully be applied.

With the development of multicore hardware, concurrent, parallel and multicore software are becoming increasingly popular. Software companies are spending a huge amount of time and resources to nd and debug the bugs. Among all types of software bugs, concurrency bugs are also important and troublesome. This type of bugs is increasingly becoming an issue particularly due to the growing prevalence of multicore hardware. In this position paper, we propose a model for monitoring and debugging Starvation bugs as a type of concurrency bugs in multicore software. The model is composed into three phases: monitoring, detecting and debugging. The monitoring phase can support detecting phase by storing collected data from the system execution. The detecting phase can support debugging phase by comparing the stored data with starvation bug's properties, and the debugging phase can help in reproducing and removing the Starvation bug from multicore software. Our intention is that our model is the basis for developing tool(s) to enable solving Starvation bugs in software for multicore platforms.

For complicated Software-Intensive System, it is always hard to guarantee the reliability and safety of software. Effective methods for detecting faults and isolating software fault from hardware fault are desiderated especially. In order to detect and isolate fault in SIS, a method called runtime software monitoring is studied, and a new kind of runtime software monitoring system(RSMS) is constructed in this paper. The RSMS can not only detect software fault by observing software behavior to determine whether it complies with its intended behavior, but also can assist to isolate software fault from hardware fault and to locate software fault based on fault symptoms acquired by our method. The software architecture of RSMS is presented from different views by using ¿4+1¿ view model and layer architectural style. The RSMS prototype is implemented through architecture-based software development method. By applying the prototype in practice, it proved that the RSMS prototype is feasible and effective for detecting and diagnosing faults in SIS.

The benefits of the analysis of software faults and failures have been widely recognized. However, detailed studies based on empirical data are rare. In this paper, we analyze the fault and failure data from two large, real-world case studies. Specifically, we explore: 1) the localization of faults that lead to individual software failures and 2) the distribution of different types of software faults. Our results show that individual failures are often caused by multiple faults spread throughout the system. This observation is important since it does not support several heuristics and assumptions used in the past. In addition, it clearly indicates that finding and fixing faults that lead to such software failures in large, complex systems are often difficult and challenging tasks despite the advances in software development. Our results also show that requirement faults, coding faults, and data problems are the three most common types of software faults. Furthermore, these results show that contrary to the popular belief, a significant percentage of failures are linked to late life cycle activities. Another important aspect of our work is that we conduct intra- and interproject comparisons, as well as comparisons with the findings from related studies. The consistency of several main trends across software systems in this paper and several related research efforts suggests that these trends are likely to be intrinsic characteristics of software faults and failures rather than project specific.

Software defect detection is particularly important for modern society, as it is a crucial step in ensuring the quality and reliability of software systems. With the emergence of artificial intelligence (AI), research in software defect detection has evolved from traditional methods to more complex approaches that utilize deep learning and large language models (LLMs). The advent of LLMs has fundamentally changed the paradigm of software development and defect detection, bringing new challenges and confusion to the field of software defect prediction research. To address these issues, we compare software defect detection methods based on traditional techniques, deep learning approaches, and LLMs through a literature review. We analyze the changes brought about by the introduction of LLMs to software development and propose new insights. Additionally, we examine the progress and trends in software defect prediction to provide inspiration for subsequent research.

Distributed control systems (DCSs) have been widely applied in many fields in recent years. With the increase of the number of processors, a DCS is subject to hardware and software failures. Therefore, a fault-tolerant scheduling algorithm based on backward non-preemptive RM (BNPRMFT), which can tolerate both hardware faults and software faults, is presented in this paper. Each task has two independent copies named primary copy and backup copy that are assigned on different processors. The backup copy of a task is executed only when its corresponding primary copy fails due to a fault. In order to decrease the number of preemptions and lower the runtime overhead of the algorithm, non-preemptive RM is applied to schedule primary copies which are assigned to the same processor, and the backward non-preemptive RM is applied to schedule backup copies and to calculate notification times of tasks. Simulation results show that BNPRMFT can obtain a higher success rate in executing primary copies and lower the runtime overhead of BPRMFT.

Even though exception handling mechanisms have been proposed as a means to improve software robustness, empirical evidence suggests that exception handling code is still poorly implemented in industrial systems. Moreover, it is often claimed that the poor quality of exception handling code can be a source of faults in a software system. However, there is still a gap in the literature in terms of better understanding exceptional faults, i.e., faults whose causes regard to exception handling. In particular, there is still little empirical knowledge about what are the specific causes of exceptional faults in software systems. In this paper we start to fill this gap by presenting a categorization of the causes of exceptional faults observed in two mainstream open source projects. We observed ten different categories of exceptional faults, most of which were never reported before in the literature. Our results pinpoint that current verification and validation mechanisms for exception handling code are still not properly addressing these categories of exceptional faults.

Faults in hardware and software are not totally avoidable not even if the components are carefully designed, implemented and tested. In this paper we present a solution for detection, localization and repair of faults in the control software for autonomous mobile robots. The presented diagnosis system uses model-based diagnosis for fault detection and localization. Furthermore, we present a method which enables the robot control software to recover from located faults. The novelty of our approach is that fault localization and repair takes place at runtime. Moreover, we present experimental results of the proposed diagnosis system obtained in the RoboCup Middle-Size scenario.

Welcome to the International Conference on Software and Systems Process (ICSSP) held in Zurich, Switzerland, on June 2nd and 3rd, 2012. Having grown from a Software Process Workshop in 2005 to the International Conference on Software Process (ICSP) in 2007, and finally to the International Conference on Software and Systems Process (ICSSP) in 2011, this conference series has established its place in the software engineering community as a respected conference focusing on research and practice related to software and systems development process. Software and software systems development use processes as one major means for achieving and ensuring the quality of the final product. This leads to specific challenges regarding software processes such as simplicity, adaptability, standard conformance, the coordination of multiple domains and lifecycles, etc. Processes from other domains (e.g., health care, manufacturing, business, aerospace, automotive systems, and others) face similar challenges. Yet, they share interesting similarities with and differences to software processes. The question is: How can we in the software domain learn from other domains to meet our software process engineering challenges? The ICSSP conferences hence connect the traditional software and systems process community with outside views and insights, broadening its scope of software development processes to system development and explicitly including processes of other domains such as health care, business, and manufacturing. By sharing process development theories and practices from such domains, ICSSP 2012 is investigating novel solutions to today's process challenges. Correspondingly, the main theme of ICSSP 2012 is Beyond Software and Software Systems Processes, signaling our goal of learning from domains other than the traditional software process community.

With the emergence of big data and remarkable improvement of computational power, deep neural network (DNN) based intelligent systems, with the superb performance on computer vision, nature language processing, and optimization processing, etc, has been acceleratingly replacing traditional software in various aspects. However, due to the uncertainty of DNN modules learned from data, the intelligent systems are more likely to exhibit incorrect behaviors. Faults in software and hardware are also inevitably in practice, where the hidden defects can easily cause model failure. These will lead to severe accidents and losses in safety- and reliability-critical scenarios, such as autonomous driving. Techniques to test the differences between actual and desired behaviors and evaluate the reliability of DNN applications at faulty conditions is therefore significant for building a trustworthy DNN system. A popular method is fault injection and various fault injection tools have been developed for ML frameworks, such as Tensorflow, PyTorch. In this paper, we present a tool, MindFI, which targets to cover a variety of faults in ML programs written in Mindspore. Data, software and hardware faults can be easily injected in general Mindspore programs. We also use MindFI to evaluate the resilience of several commonly used ML programs against a assessment metrics.

The authors present FERRARI, a fault and error automatic real-time injector, which can evaluate complex systems by emulating most hardware faults in software. The current version of FERRARI runs on SPARC workstations, in an Xwindow environment. The motivation, methodology, design, implementation, and evaluation of FERRARI are presented. The techniques used to emulate permanent faults and transient errors in software are described in detail. Experimental results are presented for several error detection techniques. They demonstrate the effectiveness of FERRARI in its role as a fault and error injector.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Reliability of composite software by different forms of uncertainty

The traditional software defects prediction methods just evaluate the software defects based the unweighted undirected network, which do not reflect the real complex software system. Therefore, this paper proposes a software security defects prediction method based on the complex network. This method improves the PageRank algorithm and develops a KeyNodeRank algorithm based on the complex network. In this method, the software system is divided into different classes and these classes constitute a weighted directed network. In addition, the KeyNodeRank algorithm evaluates and ranks the importance of class nodes in the global network. In order to examine the validity of the software defects prediction method, this paper carries out an experiment. It is found that this method not only is accurate to predict and locate software defects and but also is very significant for improving software quality and maintaining software.