Reducing Extension Edges of Concurrent Programs for Reachability Analysis

This paper addresses the analysis of concurrent programs with shared memory. Such an analysis is undecidable in the presence of multiple procedures. One approach used in recent work obtains decidability by providing only a partial guarantee of correctness: the approach bounds the number of context switches allowed in the concurrent program, and aims to prove safety, or find bugs, under the given bound. In this paper, we show how to obtain simple and efficient algorithms for the analysis of concurrent programs with a context bound. We give a general reduction from a concurrent program P, and a given context bound K, to a sequential program P such that the analysis of P can be used to prove properties about P. The reduction introduces symbolic constants and assume statements in P . Thus, any sequential analysis that can deal with these two additions can be extended to handle concurrent programs as well, under a context bound. We give instances of the reduction for common program models used in model checking, such as Boolean programs, pushdown systems (PDSs), and symbolic PDSs.

Concurrency has been with us almost from the beginning of computing. Managing and programming for concurrency is a difficult problem and various solutions have been suggested over the years. Debates on message passing vs. remote procedure call, synchronous vs. asynchronous message passing, bounded vs. unbounded buffers, active vs. passive objects etc. still continue. No solution is entirely satisfactory. Concurrent programming usually depends heavily on the nature of the problem at hand and the architecture of the target machine.

We propose a sound, complete, and automatic method for pairwise reachability analysis of higher-order concurrent programs with recursion, nested locks, joins, and dynamic thread creation. The method is based on a reduction to higher-order model checking (i.e., model checking of trees generated by higher-order recursion schemes). It can be considered an extension of Gawlitz et al.’s work on the join-lock-sensitive reachability analysis for dynamic pushdown networks (DPN) to higher-order programs. To our knowledge, this is the first application of higher-order model checking to sound and complete verification of (reasonably expressive models of) concurrent programs.

We study decision problems for parameterized verification of a formal model of ad hoc networks. We consider a model in which the network is composed of a set of processes connected to each other through a directed acyclic graph. Vertices of the graph represent states of individual processes. Adjacent vertices represent single-hop neighbors. The processes are finite-state machines with local and synchronized broadcast transitions. Reception of a broadcast is restricted to the immediate neighbors of the sender process. The underlying connectivity graph constrains communication pattern to only one direction. This allows to model typical communication patterns where data is propagated from a set of central nodes to the rest of the network, or alternatively collected in the other direction. For this model, we consider decidability of the control state reachability (coverability) problem, defined over two classes of architectures, namely the class of all acyclic networks (for which we show undecidability) and that of acyclic networks with a bounded depth (for which we show decidability). The decision problems are parameterized both by the size and by the topology of the underlying network.

We propose a new algorithm for precisely deciding a control state reachability (CSR) problem in runtime verification of concurrent programs, where the trace provides only limited observability of the execution. Under the assumption of limited observability, we know only the type of each event (read, write, lock, unlock, etc.) and the associated shared object, but not the concrete values of these objects or the control/data dependency among these events. Our method is the first sound and complete method for deciding such CSR in traces that involve more than two threads, while handling both standard synchronization primitives and ad hoc synchronizations implemented via shared memory accesses. It relies on a new polygraph based analysis, which is provably more accurate than existing methods based on lockset analysis, acquisition history, universal causality graph, and a recently proposed method based the causally-precedes relation. We have implemented the method in an offline data-race detection tool and demonstrated its effectiveness on multithreaded C/C++ applications.

Boolean programs with multiple recursive threads can be captured as pushdown automata with multiple stacks. This model is Turing complete, and hence, one is often interested in analyzing a restricted class that still captures useful behaviors. In this paper, we propose a new class of bounded under approximations for multi-pushdown systems, which subsumes most existing classes. We develop an efficient algorithm for solving the under-approximate reachability problem, which is based on efficient fix-point computations. We implement it in our tool BHIM and illustrate its applicability by generating a set of relevant benchmarks and examining its performance. As an additional takeaway, BHIM solves the binary reachability problem in pushdown automata. To show the versatility of our approach, we then extend our algorithm to the timed setting and provide the first implementation that can handle timed multi-pushdown automata with closed guards.

Obstacle avoidance can be achieved as a secondary task by appropriate inverse kinematics (IK) resolution of redundant manipulators. Most prior literature requires the time-consuming determination of the closest point to the obstacle for every calculation step. Aiming at the relief of computational burden, this paper develops what is termed a backward quadratic search algorithm (BQSA) as another option for solving IK problems in obstacle avoidance. The BQSA detects possible collisions based on the root property of a category of quadratic functions, which are derived from ellipse-enveloped obstacles and the positions of each link's end-points. The algorithm executes a backward search for possible obstacle collisions, from the end-effector to the base, and avoids obstacles by utilizing a hybrid IK scheme, incorporating the damped least-squares method, the weighted least-norm method and the gradient projection method. Some details of the hybrid IK scheme, such as values of the damped factor, weights and the clamping velocity, are discussed, along with a comparison of computational load between previous methods and BQSA. Simulations of a planar seven-link manipulator and a PUMA 560 robot verify the effectiveness of BQSA.

Stateless model checking is a fully automatic verification technique for concurrent programs that checks for safety violations by exploring all possible thread schedulings. It becomes effective when coupled with Dynamic Partial Order Reduction (DPOR), which introduces an equivalence on schedulings and reduces the amount of needed exploration. DPOR algorithms that are optimal are particularly effective in that they guarantee to explore exactly one execution from each equivalence class. Unfortunately, existing sequence-based optimal algorithms may in the worst case consume memory that is exponential in the size of the analyzed program. In this paper, we present Parsimonious-OPtimal DPOR (POP), an optimal DPOR algorithm for analyzing multi-threaded programs under sequential consistency, whose space consumption is polynomial in the worst case. POP combines several novel algorithmic techniques, including (i) a parsimonious race reversal strategy, which avoids multiple reversals of the same race, (ii) an eager race reversal strategy to avoid storing initial fragments of to-be-explored executions, and (iii) a space-efficient scheme for preventing redundant exploration, which replaces the use of sleep sets. Our implementation in Nidhugg shows that these techniques can significantly speed up the analysis of concurrent programs, and do so with low memory consumption. Comparison to TruSt, a related optimal DPOR algorithm that represents executions as graphs, shows that POP ’s implementation achieves similar performance for smaller benchmarks, and scales much better than TruSt ’s on programs with long executions.

This paper extends the notion of slicing, which was originally proposed and studied for sequential programs, to concurrent programs and presents a graph-theoretical approach to slicing concurrent programs. In addition to the usual control and data dependences proposed and studied for sequential programs, the paper introduces three new types of primary program dependences in concurrent programs, named the selection dependence, synchronization dependence, and communication dependence. The paper also propose a new program representation for concurrent programs, named the Process Dependence Net (PDN), which is an arc-classified digraph to explicitly represent the five types of primary program dependences in the programs. As a result, various notions about slicing concurrent programs can be formally defined based on the representation, and the problem of slicing a concurrent program can be simply reduced to a vertex reachability problem in its PDN representation.

In this paper we consider the (state) reachability and controllability problems of special two-level quantum systems, the so-called quantum bits via externally applied electro-magnetic field. The system is described by special a bilinear right-invariant model whose state varies on the Lie group of 2×2 special unitary matrices. We show that if two or more independent controls are used, then every state can be achieved in arbitrary time using finite energy. The mathematical construction is motivated by the demand of manipulating (or logically operating on) the state of quantum bits, and the results provide some insight into the feasibility of realizing given operations in quantum computers.

A noise maker is a tool that seeds a concurrent program with conditional synchronization primitives (such as yield()) for the purpose of increasing the likelihood that a bug manifest itself. This work explores the theory and practice of choosing where in the program to induce such thread switches at runtime. We introduce a novel fault model that classifies locations as 'good', 'neutral', or 'bad,' based on the effect of a thread switch at the location. We validate our approach by experimenting with a set of programs taken from publicly available multi-threaded benchmark. Our empirical evidence demonstrates that real-life behavior is similar to that derived from the model.

The concept of a "working-set" of a program running in a virtual memory environment is now so familiar that many of us fail to realize just how little we really know about what it is, what it means, and what can be done to make such knowledge actually useful. This follows, perhaps, from the abstract and apparently intangible facade that tends to obscure the meaning of working set. What we cannot measure of ten ranks high in curiosity value, but ranks low in pragmatic utility. Where we have measures, as in the page-seconds of SMF/MVS, the situation becomes even more curious: here a single number purports to tell us something about the working set of a program, and maybe something about the working sets of other concurrent programs, but not very much about either.This paper describes a case in which the concept of the elusive working set has been encountered in practice, has been intensively analyzed, and finally, has been confronted in its own realm. It has been trapped, wrapped, and, at last, forced to reveal it self for what it really is. It is not a number! Yet it can be measured. And what it is, together with its measures, turns out to be something not only high in curiosity value, but also something very useful as a means to predict the page faulting behavior of a program running in a relatively complex multiprogrmmed environment.The information presented here relates to experience gained during the conversion of a discrete event simulation model to a hybrid model which employs analytical techniques to forecast the duration of "steady-state" intervals between mix-change events in the simulation of a network-scheduled job stream processing on a 370/168-3AP under MVS. The specific "encounter" with the concept of working sets came about when an analytical treatment of program paging was incorporated into the model. As a result of considerable luck, ingenuity, and brute-force empiricism, the model won.Several examples of empirically derived characteristic working set functions, together with typical model results, are supported with a discussion of relevant modeling techniques and areas of application.

At present, radio frequency identification technology has been widely used in many fields, such as data acquisition, transportation, logistics management and so on. However, the collision problem in RFID technology seriously affects the performance of RFID system. Aimed at the shortcomings of search times and traffic by the traditional binary search algorithm, this paper propose an improved binary search algorithm based on the combination of dynamic binary search algorithm and backward binary search algorithm. Experimental results show that the improved algorithm greatly reduces search times and the amount of data transmission, thereby improving the recognition efficiency.

This paper presents a novel method to find the profit-maximizing Nash equilibriums in allocating generation amounts with consideration of ramp-rates under competitive market environment. In order to find the Nash equilibriums it is necessary to search all the feasible combinations of generators' outputs which satisfy various constraints. The procedure to eliminate the dominated strategies can be formulated using Bellman's optimality principle of dynamic programming problem and hence the backward or forward search algorithm of dynamic programming can be easily applied. Therefore, the Nash equilibriums are found using dynamic programming method and we found that there exist several Nash equilibriums in the generation allocation problem. Individual generators participate in a game to maximize its profit through competitions and play aa game with bidding strategies of its generation quantities in a spot market. The ramp-rate physically or technically limits generators to increase or decrease outputs in its range and restricts the number of bidding strategies of each generator. We suggest the dynamic programming to find the Nash equilibriums while removing the dominated strategies in each stage (or each time). In the case studies, we analyzed the generation allocation game for a 12-hour multi-stage and compared it with the results of dynamic economic dispatch. Both of the two cases were considered generator's ramp-rate effects.

May-Happen-in-Parallel (MHP) analysis is a very important and fundamental mechanism to facilitate concurrent program analysis. But the limitation of its efficiency keep it away from being practical and effective in analyzing large scale real world concurrent programs. We proposed a novel MHP algorithm by performing a reachability analysis on a so-called parallel reachability graph of a program. The MHP algorithm mainly comprises two phases: pre-computation of initial MHP information and top-down propagation of this information along the parallel reachability graph. Our algorithm is fast as it has a low complexity O(|N|+|E|), in which N is the number of nodes in the parallel reachability graph and E is the number of edges in this graph. Our preliminary experiment on 13 concurrent programs indicates that our approach is extremely faster than two state-of-art approaches, respectively achieving a relative geometry average speed up of 395.53× and 136.37×, while yielding the same precision with these two approaches.