Infeasible Paths Research Articles

Automatic detection of infeasible paths in large-scale program based on program summaries

The existence of infeasible paths in a program reduces the coverage of test cases and causes a waste of valuable testing resources. Detecting infeasible paths allows for focusing testing resources on feasible paths. This paper introduces a method for detecting infeasible paths based on program summaries. Our proposed method partitions the program into sequential statements, conditional statements and loop statements, and automatically generates statement summaries and function summaries. It analyzes the summaries to extract the path constraints and determines the feasibility of paths. We implemented a detection tool named DTSIP based on this method, and conducted experiments using a set of benchmark programs and open source projects. The results confirm the effectiveness of our method in detecting infeasible paths. It can detect both intraprocedural and interprocedural infeasible paths, demonstrating its broad applicability. Our method overcomes challenges associated with analyzing complex paths, achieving efficient feasibility determination while reducing processing time.

Autonomous Emergency Landing for Fixed-Wing Aircraft with Energy-Constrained Closed-Loop Prediction

This paper presents a new approach for autonomous motion planning for aircraft suffering from a loss-of-thrust emergency. Specifically, we show how modifications to the Closed-Loop Rapidly exploring Random Trees (CL-RRT) framework combined with controlled energy dissipation can enable rapid and effective kinodynamic motion planning. This CL-RRT Glide algorithm uses closed-loop prediction not only for node connections but also to estimate the remaining energy and prune infeasible paths. This greatly speeds up the search process, which is essential for emergency situations. In addition, we improve the ability of the gliding aircraft to reach a goal position and energy state. We do so by creating a Dissipative Total Energy Control Scheme (TECS). Dissipative TECS enables the glider to lose excess altitude in order to reach a desired energy level. Simulation results illustrate how the proposed methods enable faster motion planning. We also integrate the system into a small unmanned aerial vehicle system and experimentally demonstrate autonomous glide planning and execution during a motor-failure event. This type of algorithm can primarily benefit unmanned aircraft but can also serve to assist pilots in stressful emergency situations.

Using infeasible path cuts to solve Electric Vehicle Routing Problems with realistic charging functions exactly within a branch-and-cut framework

The paper investigates the Electric Vehicle Routing Problem with a non-linear concave and strictly monotonic increasing charging function. In the literature, the non-linear charging function is typically approximated by a piecewise linear charging function which does not overestimate the real charging function in any point. As the piecewise linear charging function underestimates the real state-of-charge in some points, such an approximation excludes feasible solutions from the solution space. To overcome this drawback we introduce a new method to determine a piecewise linear charging function overestimating the real charging function in a way that the area between both functions is minimized as well as an adaptation of a known linearization to include the piecewise linear charging function in a branch-and-cut approach. Thereby, we include infeasible solutions in the solution space. To declare them infeasible again we check every integer solution obtained in the branch-and-cut procedure and add an infeasible path cut if the solution is infeasible for the real charging function such that the procedure terminates with an optimal solution for the real charging function. Our approach is evaluated in a computational study in which instances with up to 100 customers were solved to optimality. Moreover, we evaluate the trade-off between a more complex model formulation due to more binary variables if the number of supporting points for the piecewise linear approximation is increased and the higher approximation error if fewer supporting points are used.

Forest GUMP: a tool for verification and explanation

AbstractIn this paper, we present Forest GUMP (for Generalized, Unifying Merge Process) a tool for verification and precise explanation of Random forests. Besides pre/post-condition-based verification and equivalence checking, Forest GUMP also supports three concepts of explanation, the well-known model explanation and outcome explanation, as well as class characterization, i.e., the precise characterization of all samples that are equally classified. Key technology to achieve these results is algebraic aggregation, i.e., the transformation of a Random Forest into a semantically equivalent, concise white-box representation in terms of Algebraic Decision Diagrams (ADDs). The paper sketches the method and demonstrates the use of Forest GUMP along illustrative examples. This way readers should acquire an intuition about the tool, and the way how it should be used to increase the understanding not only of the considered dataset, but also of the character of Random Forests and the ADD technology, here enriched to comprise infeasible path elimination. As Forest GUMP is publicly available all experiments can be reproduced, modified, and complemented using any dataset that is available in the ARFF format.

Search-Based Software Test Data Generation for Path Coverage Based on a Feedback-Directed Mechanism

Automatically generating test cases by evolutionary algorithms to satisfy the path coverage criterion has attracted much research attention in software testing. In the context of generating test cases to cover many target paths, the efficiency of existing methods needs to be further improved when infeasible or difficult paths exist in the program under test. This is because a significant amount of the search budget (i.e., time allocated for the search to run) is consumed when computing fitness evaluations of individuals on infeasible or difficult paths. In this work, we present a feedback-directed mechanism that temporarily removes groups of paths from the target paths when no improvement is observed for these paths in subsequent generations. To fulfill this task, our strategy first organizes paths into groups. Then, in each generation, the objective scores of each individual for all paths in each group are summed up. For each group, the lowest value of the summed up objective scores among all individuals is assigned as the best aggregated score for a group. A group is removed when no improvement is observed in its best aggregated score over the last two generations. The experimental results show that the proposed approach can significantly improve path coverage rates for programs under test with infeasible or difficult paths in case of a limited search budget. In particular, the feedback-directed mechanism reduces wasting the search budget on infeasible paths or on difficult target paths that require many fitness evaluations before getting an improvement.

Branch-and-refine for solving time-expanded MILP formulations

One of the standard approaches for solving discrete optimization problems which include the aspect of time, such as the traveling salesman problem with time windows or the shortest path problem with time windows is to derive a so-called time-indexed formulation. If the problem has an underlying structure that can be described by a graph, the time-indexed formulation is usually based on a different, extended graph, commonly referred to as the time-expanded graph. The time-expanded graph can often be derived in such a way that all time constraints are incorporated in its topology, and therefore algorithms for the corresponding time-independent variant become applicable. The downside of this approach is, that the sets of vertices and arcs of the time-expanded graph are much larger than the ones of the original graph. In recent works, however, it has been shown that for many practical applications a partial graph expansion, that might contain time infeasible paths, often suffices to find a proven optimal solution. These approaches, instead, iteratively refine the original graph and solve a relaxation of the time-expanded formulation in each iteration. When the solution of the current relaxation is time feasible an optimal solution can be derived from it and the algorithm terminates. In this work we present new ideas, that allow for the propagation of information about the optimal solution of a coarser graph to a more refined graph and show how these can be used in algorithms, which are based on graph refinement. More precisely we present a new algorithm for solving Mixed Integer Linear Program (MILP) formulations that allows for the graph refinement to be carried out during the exploration of the branch-and-bound tree instead of restarting whenever the optimal solution was found to be infeasible. For demonstrating the practical relevance of this algorithm we present numerical results on its application to the shortest path problem with time windows and the traveling salesman problem with time windows.

The Fragility-Constrained Vehicle Routing Problem with Time Windows

We study a new variant of the well-studied vehicle routing problem with time windows (VRPTW), called the fragility-constrained VRPTW, which assumes that (1) the capacity of a vehicle is organized in multiple identical stacks; (2) all items picked up at a customer are either “fragile” or not; (3) no nonfragile items can be put on top of a fragile item (the fragility constraint); and (4) no en route load rearrangement is possible. We first characterize the feasibility of a route with respect to this fragility constraint. Then, to solve this new problem, we develop an exact branch-price-and-cut (BPC) algorithm that includes a labeling algorithm exploiting this feasibility characterization to efficiently generate feasible routes. This algorithm is benchmarked against another BPC algorithm that deals with the fragility constraint in the column generation master problem through infeasible path cuts. Our computational results show that the former BPC algorithm clearly outperforms the latter in terms of computational time and that the fragility constraint has a greater impact on the optimal solution cost (compared with that of the VRPTW) when vehicle capacity decreases, stack height increases, and for a more balanced mix of customers with fragile and nonfragile items. Funding: This work was supported by the Natural Sciences and Engineering Research Council of Canada [Grants RGPIN 2015-06289 and RGPIN 2022-03916]. Supplemental Material: The online appendices are available at https://doi.org/10.1287/trsc.2022.1168 .

Multiobjective Genetic Algorithm for Class Testing using OCL Class Contract Specifications: A Framework

It has been a software trend to build large-scale complex systems with high reliability. Due to the size of the software and the dynamic requirements of the stakeholders, it becomes hard to test those software systems manually. This may lead the software to fatal failures and cause irrecoverable catastrophic damage. To be safe, the software system must be investigated thoroughly before it is too late. Test sequence generation for Unified Modeling Language (UML) class models from their semiformal Object Constraint Language specifications can be helpful in identifying the defects in the early phase of the software life cycle. The existing approaches suffer from inherent problems of exhaustive exploration of finite state machines (infeasible paths, exponential number of test sequences, and uncertainty of completion of testing). Evolutionary algorithms can greatly help by optimizing the test sequences to get optimal coverage, minimal cost, and higher quality. The proposed approach helps us to improve the testing of Unified Modeling Language (UML) model-based software, by testing the conformance to semiformal class operation contract specifications (specified in the form of Object Management Group (OMG) standard and Object Constraint Language (OCL) semiformal language). The presented research achieved two main goals: (1) automation of testing process and conformance to standards of the current technique of test sequence generation, bridging the gap between the research and industry; (2) improvement in the state of the art approach through the application of multiobjective genetic algorithms (MOGAs). A case study along with the results achieved through the proposed technique is presented as well, clearly reflecting the significance of the proposed research.

OmpTG: From OpenMP Programs to Task Graphs

Real-time systems are shifting them from single-core to multi-core processors. Software must be parallelized to fully utilize the computation power of multi-core architectures. OpenMP is a promising framework to develop parallel real-time software on multi-cores. OpenMP programs keep certain similarity to real-time task graph models, and this motivates much recent work done on real-time scheduling of OpenMP tasks. However, these studies conduct evaluations with randomly generated task graphs, which cannot well capture the structure features of realistic OpenMP programs. To fill the gap between theoretical real-time scheduling research and the OpenMP software reality, we develop an ompTG tool for transforming OpenMP programs into parallel task graphs. ompTG prepares a way to exhibit OpenMP such that the researchers in real-time community can easily understand: An OpenMP system consists of a set of tasks. There are interdependencies among tasks, and each task has an intra structure of the control-flow graph. Besides the topology of OpenMP tasks, we also provide a safe WCET for each vertex of OpenMP task graphs by using static WCET analysis techniques. Moreover, we derive the flow facts, e.g, infeasible path and loop bounds for the task graph, which is necessary information for real-time scheduling and analysis. As a case study, we collect 12 OpenMP programs from the BOTS benchmark, and transform them into task graphs, demonstrating the usage of ompTG.

A Research for Executable Path Automatic Generation Method Based on EFSM

Extended finite state machine (EFSM) is currently one of the most widely used model in the field of software testing. EFSM model is an enhanced model based on finite state machine (FSM). Automated test data generation is still a challenging problem due to the complexity of EFSM which extends the input and output parameters, context variables as well as the predicate condition. These reasons lead to conflict of the context variable with the enable conditions in the transition path. In order to avoid infeasible path generation, this paper proposes a method based on modified breadth first search to generate feasible transition path (MBFS-FTP). To solve the problem of state explosion in path generation, this paper converts state diagram to transition diagram on EFSM model. In order to make the EFSM static model can be driven execution, this paper uses UML model and generate executable model, so that implements EFSM execute dynamically. When using breadth-first search algorithm (MBFS) on every target transition to generate an executable transition path, the conflict detection algorithm is utilized to the transition path for conflict decision, avoiding the occurrence of an infeasible transition path. Considering target transition has multiple feasible transition paths, this paper combines suggested penalized value of definition-predicate-use (def-p-use) pair and length of feasible transition path, and then develops the measurement method of feasible transition path, and obtained a set of feasible transition path containing all of transitions. Through the experiment on two actual EFSM model, verifying the effectiveness of MBFS-FTP for feasible transition automatic generation, the experimental results show that MBFS-FTP can reduce the feasible transition path length, and make transition paths are more easily to be triggered at the times of generating test cases lately, furthermore, it can improve the efficiency of generate feasible transition path and save a lot of time.

Robust vehicle routing under uncertainty via branch-price-and-cut

This paper contemplates how branch-price-and-cut solvers can be employed along with the robust optimization paradigm to address parametric uncertainty in the context of vehicle routing problems. In this setting, given postulated uncertainty sets for customer demands and vehicle travel times, one aims to identify a set of cost-effective routes for vehicles to traverse, such that the vehicle capacities and customer time window constraints are respected under any anticipated demand and travel time realization, respectively. To tackle such problems, we propose a novel approach that combines cutting-plane techniques with an advanced branch-price-and-cut algorithm. Specifically, we use deterministic pricing procedures to generate “partially robust” vehicle routes and then utilize robust versions of rounded capacity inequalities and infeasible path elimination constraints to guarantee complete robust feasibility of routing designs against demand and travel time uncertainty. In contrast to recent approaches that modify the pricing algorithm, our approach is both modular and versatile. It permits the use of advanced branch-price-and-cut technologies without significant modification, while it can admit a variety of uncertainty sets that are commonly used in robust optimization but could not be previously employed in a branch-price-and-cut setting.

Research on an intelligent path planning algorithm for robot using electrical control technology

In view of the shortcomings of traditional genetic algorithm in path planning, such as infeasible path, falling into local optimization, too many turning times and so on, an improved adaptive genetic algorithm is proposed. A priori knowledge is used to optimize the initial population, and the initial population that does not intersect with obstacles is obtained. The probability formulas of crossover and mutation are designed to avoid falling into local optimization, so as to improve the convergence speed. The smoothness of the path and the shortest path are introduced into the fitness function as the evaluation criteria to make the planned path more efficient. The simulation results show that: compared with the basic algorithm, when the number of obstacles is 20:00, the path of the improved algorithm is reduced by 4.2%; when the number of obstacles is 115, the path is reduced by 25.1%. With the continuous increase of obstacles, the percentage of path reduction shows an upward trend, and the number of iterations of the algorithm and the number of turning points in the path are better than the basic genetic algorithm.

Unstructured with a Point: Validation and Robustness Evaluation of Point-Cloud Based Path Planning

<div class="section abstract"><div class="htmlview paragraph">Robust autonomous navigation in unstructured environments is an unsolved problem and critical to the operation of autonomous military and rescue ground vehicles. Two-dimensional path planners operating on occupancy grids or costs maps can produce infeasible paths when the operational area includes complex terrain. Recently, sample-based path planners that plan on LiDAR-acquired point-cloud maps have been proposed. These approaches require no discretization of the operational area and provide direct pose estimation by modeling vehicle and terrain interaction. In this paper, we show that direct sample-based path planning on point clouds is effective and robust in unstructured environments. Robustness is demonstrated by completing a system parameter sensitivity analysis of the system in an Unreal simulation environment and partnered with field validation.</div></div>

Поиск уязвимостей небезопасного использования помеченных данных в статическом анализаторе Svace

The paper is dedicated to search for taint-based errors in the source code of programs, i.e. errors caused by unsafe use of data obtained from external sources, which could potentially be modified by an attacker. The interprocedural static analyzer Svace was used as a basis. The analyzer searches both for defects in the program and searches for suspicious places where the logic of the program may be violated. The goal is to find as many errors as possible at an acceptable speed and a low level of false positives (< 20-35%). To find errors, Svace with help of modified compiler builds a low-level typed intermediate representation, which is used as an input to the main SvEng analyzer. The analyzer builds a call graph and then performs summary-based analysis. In this analysis, the functions are traversed according to the call graph starting from the leaves. After analyzing the function, its summary is created, which will then be used to analyze the call instructions. The analysis has both high speed and good scalability. Intra-procedural analysis is based on symbolic execution with the union of states at merge points of paths. An SMT solver can be used to filter out infeasible paths for some checkers. In this case, the SMT-solver is called only if there is a suspicion of an error. The analyzer has been expanded to find defects of tainted data using. The checkers are implemented as plugins by using the source-sink scheme. The sources are calls of library functions that receive data from outside the program, as well as the arguments of the main function. Sinks are accessing to arrays, using variables as a step or loop boundary, calling functions that require checked arguments. Checkers covering most of the possible types of vulnerabilities for tainted integers and strings have been implemented. The Juliet project was used to assess the coverage. The false negative rate ranged from 46,31% to 81.17% with a small number of false positives.

Core-guided method for constraint-based multi-objective combinatorial optimization

Multi-Objective Combinatorial Optimization(MOCO), which consists of several conflicting objectives to be optimized, finds an ever-increasing number of uses in many real-world applications. In past years, the research of MOCO mainly focuses on evolutionary algorithms. Recently, constraint-based methods come into the view and have been proved to be effective on MOCO problems. This paper builds on the previous works of constraint-based algorithm MCSEnumPD(AAAI-18) using path diversification method. Due to the inadequacy that the original method fails to prune the redundant search space effectively, this paper proposes the definition of infeasible path and develops a novel algorithm that exploits the properties of unsatisfiable cores, referred as CgPDMCS. The approach extends MCSEnumPD algorithm with a core-guided path diversification method, which avoids solving infeasible paths representing the supersets of the unsatisfiable cores. Experimental results show that the novel approach provides further performance gains over the previous constraint-based algorithms, especially for the instances tightly constrained.

Mining understandable state machine models from embedded code

Program understanding is a time-consuming and tedious activity for software developers. Manually building abstractions from source code requires in-depth analysis of the code. Automatic extraction of such models is possible, but cannot derive meaningful abstractions that are not already contained in the code. The automated extraction even has problems to decide which aspects of the code are important and which are not. Therefore, interactive semi-automatic approaches are the compromise of choice. In this article, we describe how state machines that describe the behaviour of a function can be extracted from code. The approach includes interaction – the user decides which aspects of the identified potentially relevant information is really relevant and which is not. This helps to reduce the resulting state machines to an understandable degree. However, these state machines in their raw form have transition conditions that are very complex and thus not understandable for humans. Therefore, we also introduce a technique to reduce these guards to an understandable form. The technique is a combination of heuristic logic minimization, exploitation of infeasible paths, and using transition priorities. We evaluate the approach on industrial embedded C code, first in a case study with hundreds of extracted state machines, and then in two experiments with professional developers. The results show that the approach is highly effective in making the guards understandable, and that guards reduced by our approach and presented with priorities are easier to understand than guards without priorities. We also show that the overall approach is beneficial for program comprehension. The guard reduction approach itself is quite generic and can also be applied to other problems. We demonstrate that for the simplification of mode switch logic.

Infeasible Path Detection Based on Code Pattern and Backward Symbolic Execution

This paper sets out to reveal the relationship between code pattern and infeasible paths and gives advices to the selection of infeasible path detection techniques. Lots of program paths are proved to be infeasible, which leads to imprecision and low efficiency of program analysis. Detection of infeasible paths is required in many areas of software engineering including test coverage analysis, test case generation, and security vulnerability analysis. The immediate cause of path infeasibility is the contradiction of path constraints, whose distribution will affect the performance of different program analysis techniques. But there is a lack of research on the distribution of contradict constraints currently. We propose a code pattern based on the empirical study of infeasible paths; the statistical result proves the correlation of the pattern with contradict constraints. We then develop a path feasibility detection method based on backward symbolic execution. Performance of the proposed technique is evaluated from two aspects: the efficiency of detecting infeasibility paths for specific program element and the improvement of applying the technique on code coverage testing.

A novel approach for infeasible path optimization of distillation-based flowsheets

In this work, a new approach for simultaneous steady state simulation and optimization of distillation-based flowsheets is presented. The process simulation is embedded in an optimization problem with a small number of optimization variables and constraints. Hence, no specialized solvers are needed. Moreover, an arbitrary number of specifications in the form of equalities or inequalities can be set in the problem formulation. This matches the process engineering demands usually much better than specifying a given quantity of fixed numbers. The remaining process variables for distillation columns are calculated from stage-to-stage using fixed-point iterations as developed and analyzed in previous work of the authors (Hoffmann et al., 2017). To illustrate the new approach, typical examples for process simulation and optimization of distillation-based flowsheets including several columns and also recycle streams are presented. For such distillation-based flowsheets an algorithm is presented that determines a possible calculation sequence of units within one iteration of the optimization algorithm.

IMPROVING THE PRECISION OF FLOW-SENSITIVE LIFETIME ANALYSIS

Object lifetimes are a common source of bugs in C++ that can cause crashes, unexpected behavior, or even security vulnerabilities. Herb Sutter, the chair of the C++ standard committee proposed a flow-sensitive analysis to catch lifetime errors statically. Sadly, this analysis is prone to false positives unless the author follows some specific guidelines. We developed mitigations to eliminate some classes of false positives to make it easier to write conforming code. The first mitigation fixes a common false positive from a frequently used coding pattern by introducing local path-sensitivity. The second one is a filter based on reaching definitions and dominance algorithms to remove reports that might be the result of analyzing infeasible paths. We tested the effectiveness of the methods on the open source Google Fuchsia project.

A Firefly Algorithm With Self-Adaptive Population Size for Global Path Planning of Mobile Robot

In the simulation experiment of path planning of mobile robot based on firefly algorithm, it is found that the matching relationship between the number of fireflies and obstacles in the iterative process has significant conflict impacts on exploration ability and computational complexity of the algorithm. In order to solve the above problem, an optimal method of path planning based on firefly algorithm with self-adaptive population size is proposed. Firstly, the evaluation of degree of collision is established at the cost of avoiding collision. Based on the degree of collision of the population, two nonlinear functions are proposed to determine the population size. Then, individuals are added or deleted for the firefly population. Individuals are added randomly. The feasible solution and the infeasible solution are distinguished in firefly population, and delete the fireflies in the infeasible solution first when performing the eliminating operation. Finally, on the basis of the existing methods for dealing with infeasible paths, a coefficient that is adaptively adjusted according to the population size is introduced to control the degree to which the infeasible path approaches the feasible area. Compared with fixed population size firefly algorithm, the proposed algorithm has better performance in terms of solution stability, convergence speed and running time.