Atef Mohamed

On Failure Propagation in Component-Based Software Systems

Ensuring reliability in component-based software systems (CBSSs) is important for their effective applications in large scale and safety critical systems. However, only few techniques consider failure propagation in system architectures for system reliability assessment. Those techniques focus only on content failure propagation through component interfaces. Therefore, the evaluation of CBSS architectures based on the current techniques fails to consider the impacts of all failure types on system reliability. In this paper, we present a failure propagation analysis technique for CBSSs. We analyze failure propagation based on architectural service routes (ASRs). An ASR is a sequence of components that are connected through interfaces. We discuss the attributes of ASRs with respect to system components and present their impacts on failure propagation and consequently on the reliability of CBSSs. Further analysis determines upper and lower bounds of failure propagation among components and shows some relationships between system reliability and architectural attributes. Our technique is not limited to any failure type, and it considers failure scattering and masking. Therefore, unlike other works, the proposed technique demonstrates more accurate representation of the practical aspect of failure propagation in CBSSs. The technique can also be used to achieve reliable designs in the early design stages of CBSSs and to localize component faults in the operational stage. We compare different example architectures based on their impacts on system reliability.

Improving Reliability and Safety by Trading off Software Failure Criticalities

A number of voters have been proposed for n-version programming diversity designed software systems. The knowledge about various software failure criticalities is not incorporated in the decisions of these voters. Moreover, failure classes contradict among each other with respect to their fault tolerance requirements, as a result, current voters either consider different failures equally or they mask only certain types of failures. Therefore, the voters need to consider system criticalities to different failures based on their fault tolerance requirements trade-off. We propose an approach for trading off system criticalities to different failures. In this approach, we introduce two implementation parameters: the voter constraint hardness and the number of participants in the voting process. We use failure criticalities trade-off to determine the optimal values of these two parameters. This trade-off enhances the ability of a voter to consider different failure criticalities. It also decreases the rate of performance failures. We provide an analysis for the relationships between the implementation parameters and the failure occurrence rate of each failure class. We derive system reliability and safety based on our approach, and we show gains in both of them. The proposed approach can be used to build fault tolerant systems based on n-version programming that use any generic or hybrid voter.

Failure Type-Aware Reliability Assessment with Component Failure Dependency

Most of the existing reliability assessment techniques assume that components fail independently and consider different types of failures equally. By disregarding component failure dependency, these techniques assume inappropriately that a component failure does not affect any other component and it directly leads to a system failure. Also, by considering different failure types equally, reliability assessment disregards various criticality levels or severities of different failures. In practice, component failures affect other system components and vary with respect to their criticality levels. Recently, some propagation-based techniques incorporate component failure dependency in the reliability measure through failure propagation analysis by focusing only on value failures. Therefore, other failures (e.g., silent and performance) are not considered in the current failure propagation analysis. In this paper, we present an approach for reliability assessment of fault tolerant component-based software systems considering component failure dependency and enabling failure type-awareness. We incorporate component failure dependency in the reliability quantification by analyzing failure propagation among system components. We enable failure type-awareness by analyzing the propagation of different failure types in fault tolerant components and the architectural service routes among them. Finally, we aggregate the impacts of these failure types on system reliability.

A taxonomy of software architecture-based reliability efforts

Due to the complexity of the current software systems and the diversity of their architectural styles and component models, architecture-based reliability is becoming a more important quality requirement than ever before. Architecture-based reliability efforts depend on the behavior of individual components and their interactions with respect to their influences on the system reliability. Depending on different viewpoints and assumptions, a component takes various definitions and forms. As a result, numerous reliability works that involve varieties of the underlying strategies, objectives, and parameters are proposed for software architectures. Classifying these efforts is important for creating and selecting potential solutions that handle the reliability of software applications. In this paper, we provide a taxonomy of architecture-based reliability efforts. We classify these efforts according to the reliability goals, component abstraction, and level of granularity. We explain the existing techniques considering their assumptions with respect to these classification parameters and provide detailed description about the specific issues and considerations of each class.

Architectural design decisions for achieving reliable software systems

Software architectural design decisions are key guidelines to achieve non-functional requirements of software systems in the early stages of software development. These decisions are also important for justifying the modifications of dynamic architectures during software evolution in the operational phase. Incorporating reliability goals in software architectures is important for successful applications in large and safety-critical systems. However, most of the existing software design mechanisms do not consider the architectural reliability (the impact of software architecture on system reliability). As a result, alternative software architectures cannot be compared adequately with respect to software system reliability. In this paper, we extend our previous work on failure propagation analysis to propose a selection framework for incorporating reliability in software architectures. The selection criterion in this framework exploits architectural attributes to appropriately select software architectures based on their reliabilities. We provide algorithms to derive the architectural attributes required by the model and to select the appropriate architecture using a quick and a comprehensive decision approach for minor and major architectural changes, respectively.

At What Level of Granularity Should We be Componentizing for Software Reliability

In component-based software systems (CBSSs), software designers need to decide about decomposition level (level of granularity) which involves component sizes and the number of components. In these systems, decomposition level is important due to its major impacts on reliability. However, the basis to choose the decomposition level of a CBSS has not been addressed adequately in the existing research. On the other hand, software system components may vary with respect to their criticalities to different failures. The knowledge about component failure criticalities are currently not incorporated in the architectural design decisions of these systems. As a result, these systems consider different failures equally and disregard the various severities of different failures. In this paper, we study the level of decomposition of CBSSs with respect to its impact on their reliabilities based on various component failure criticalities. We discuss the level of decomposition impacts on CBSS architectures with respect to the architectural attributes and component failure criticalities. We derive the reliability of these systems and show the level of decomposition impacts on these system reliabilities.

A Control Flow Representation for Component-Based Software Reliability Analysis

Current reliability analysis techniques encounter a prohibitive challenge with respect to the control flow representation of large software systems with intricate control flow structures. Some techniques use a component-based Control Flow Graph (CFG) structure which represents only inter-component control flow transitions. This CFG structure disregards the dependencies among multiple outward control flow transitions of a system component and does not provide any details about a component internal control flow structure. To overcome these problems, some techniques use statement-based or block-based CFGs. However, these CFG structures are remarkably complex and difficult to use for large software systems. In this paper, we propose a simple CFG structure called Connection Dependency Graph (CDG) that represents inter-component and intra-component control flow transitions and preserves the dependencies among them. We describe the CDG structure and explain how to derive it from a program source code. Our derivation exploits a number of architectural patterns to capture the control flow transitions and identify the execution paths among connections. We provide a case study to examine the effect of program size on the CDG, the statement-based, and the block-based CFGs by comparing them with respect to complexity using the PostgreSQL open source database system.

A Connection-Based Signature Approach for Control Flow Error Detection

Control Flow Errors (CFEs) are major impairments of software system correctness. These CFEs can be caused by operational faults with respect to the execution environment of a software system. Several techniques are proposed to monitor the control flow using signature-based approaches. These techniques partition a software program into branch-free blocks and assign a unique signature for each block. They detect CFEs by comparing the runtime signatures of these blocks with pre-computed signatures based on the program Control Flow Graph (CFG). Unfortunately, branch-free block partitioning does not completely include all the program connections. Consequently, these techniques may fail to detect some invalid transitions due to lack of signatures associated with those missing connections. In this paper, we propose a connection-based signature approach for CFE detection. We first describe our connection-based signature structure in which we partition the program components into Connection Implementation Blocks (CIBs). Each CIB is associated with a Connection-based CFG (CCFG) to represent the control structure of its code segment. We present our control flow monitor structure and CFE checking algorithm using these CCFGs. The error detection approach is evaluated using PostgreSQL open-source database. The results show that this technique is capable of detecting CFEs in different software versions with variable numbers of randomly injected faults.

The Level of Decomposition Impact on Component Fault Tolerance

In fault tolerant software systems, the Level of Decomposition (LoD) where design diversity is applied has a major impact on software system reliability. By disregarding this impact, current fault tolerance techniques are prone to reliability decrease due to the inappropriate application level of design diversity. In this paper, we quantify the effect of the LoD on system reliability during software recomposition when the functionalities of the system are redistributed across its components. We discuss the LoD in fault tolerant software architectures according to three component failure transitions: component failure occurrence, component failure propagation, and component failure impact. We illustrate the component aspects that relate the LoD to each of these failure transitions. Finally, we quantify the effect of the LoD on system reliability according to a series of decomposition and/or merge operations that may occur during software recomposition.