Abstract:
A set of techniques for analyzing concurrent programs that combines the power of symbolic model checking to explore large state spaces, and partial order and transaction-based reduction techniques to manage the size of explored state space.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS  
       [0001]     This application claims the benefit of U.S. Provisional Application No. 60/743,055 filed 20 Dec. 2005 the entire contents of which are incorporated by reference as if set forth at length herein. 
     
    
     FIELD OF THE INVENTION  
       [0002]     This invention relates generally to the field of computer software and in particular it pertains to a software verification methodology for concurrent programs.  
       BACKGROUND OF THE INVENTION  
       [0003]     The widespread use of concurrent software in modem computing systems necessitates the development of effective verification methodologies for multi-threaded programs. As can be appreciated however, subtle interactions between threads makes multi-threaded software behaviorally complex and particularly hard to analyze and—as a result—formal methodologies are employed for their debugging. Not surprisingly, model checking—both symbolic and explicit state—for the verification of concurrent software has been an active area of research.  
         [0004]     Explicit state model checkers, such as Verisoft (See e.g., P. Godefroid, “ Model Checking For Programming Languages Using Verisoft”, POPL &#39; 97, pp. 174-186, 1997) explore an enumeration of the states and transitions of the concurrent program under study. Additional techniques such as state hashing for compaction of state representations, and partial order methods are typically used to avoid exploring all of the interleavings and transitions of constituent threads. And while these techniques have proven to be effective at state space reduction, they do not address scalability problems that arise due to state explosion when model checking large-scale concurrent programs.  
         [0005]     Symbolic model checkers—on the other hand—avoid an explicit enumeration of the state space by using symbolic representations of sets and states and transitions. One successful approach in this regard was the use of Binary Decision Diagrams (BDDs) to succinctly represent large state spaces for the purpose of model checking (See, e.g., K. L. McMillan, “ Symbolic Model Checking: An Approach To The State Explosion Problem , Kluwer Academic Publishers, 1993). Subsequently, Boolean Satisfiability (SAT)-based techniques have become popular both for finding software bugs using SAT-based bounded model checking (BCC) and generating proofs via SAT-based unbounded model checking (UMC).  
         [0006]     Given their importance, techniques that improved upon or extended the applicability of model checking would represent a significant advance in the art.  
       SUMMARY OF THE INVENTION  
       [0007]     We have developed, in accordance with the principles of the invention, methodology which advantageously leverages the synergy which results from combining partial order techniques to reduce the state space of a system to be explored with the power of symbolic model checking techniques to explore large state spaces. In sharp contrast to existing methods that employ BDDs which encode the entire state of a given concurrent program thereby producing a state space explosion—the method of the present invention provides the freedom to use any technique of choice—either SAT or BDD-based. As those skilled in the art will readily appreciate, such an approach is much more scalable than the prior art approach(es) which required the use of BDDs.  
         [0008]     According to an aspect of the present invention, a given concurrent program is translated into a circuit-based (finite-state) model. Accordingly, a finite model for each individual thread is obtained wherein each variable of the thread is represented in terms of a vector of binary-valued latches and a Boolean next-state function (or relation) for each latch. Next—using a scheduler—the circuits for the individual threads are composed into one single circuit for the entire concurrent program. Verification is then performed on this circuit and partial order techniques are incorporated into the framework by statically augmenting the circuit-based Boolean encoding of the concurrent program with additional constraints. According to an aspect of the present invention—these constraints restrict the transitions explored from each global state to a minimal conditional stubborn set of that state.  
         [0009]     Viewed from yet another aspect, the present invention provides an improved method for identifying transactions on-the-fly that is based upon analyzing patterns of lock acquisitions. In sharp contrast, prior art methods employ lockset based analysis. As those skilled in the art will appreciate, lockset based methods for state space reduction exploit the ability of locks to enforce mutually exclusive access to regions of code encapsulated between locking and unlocking operations. Such prior art lockset methods rely on the assumption that a concurrent program follows a lock discipline in accessing shared variables, i.e., that all accesses to a shared variable sh are protected by the same lock I sh .  
         [0010]     According to an aspect of the present invention however, patterns of lock acquisitions are analyzed—rather than locksets—thereby producing a demonstrably more comprehensive result. In addition, a method according to the present invention does not require nor rely on a concurrent program exhibiting lock discipline. Consequently, the present invention permits the use of lock-based reductions for a broader class of concurrent programs.  
         [0011]     Viewed from yet another aspect, the present invention permits the transparent incorporation of lock-pattern based transactions into partial order reductions by improved conditional dependency detection via the addition of extra constraints—which are not incorporated into the transition relation a-priori but dynamically while unrolling the executions of the threads. As a result, increased granularity of transitions due to transactions can be captured as a reduction in the sizes of conditional stubborn sets of states.  
         [0012]     Finally, the present invention provides a new approach for model checking concurrent programs that combines the power of symbolic techniques with partial order reduction and on-the-fly transactions while—at the same time—retaining the flexibility to employ a broad arsenal of model checking techniques—both SAT and BDD-based—to check not just reachability but richer classes of linear temporal problems as well. 
     
    
     BRIEF DESCRIPTION OF THE DRAWING  
       [0013]     A more complete understanding of the present invention may be realized by reference to the accompanying drawing in which:  
         [0014]      FIG. 1  is a program segment showing threads T 1    FIG. 1 ( a ) and T 2    FIG. 1 ( b ) with unprotected access to x;  
         [0015]      FIG. 2  is a program segment showing threads T 1    FIG. 1 ( a ) and T 2    FIG. 1 ( b )with unprotected access to x illustrating the identification of transactions in the absence of lock discipline; and  
         [0016]      FIG. 3  is a block diagram depicting an overview of the present invention. 
     
    
     DETAILED DESCRIPTION  
       [0017]     The following merely illustrates the principles of the invention. It will thus be appreciated that those skilled in the art will be able to devise various arrangements which, although not explicitly described or shown herein, embody the principles of the invention and are included within its spirit and scope.  
         [0018]     Furthermore, all examples and conditional language recited herein are principally intended expressly to be only for pedagogical purposes to aid the reader in understanding the principles of the invention and the concepts contributed by the inventor(s) to furthering the art, and are to be construed as being without limitation to such specifically recited examples and conditions.  
         [0019]     Moreover, all statements herein reciting principles, aspects, and embodiments of the invention, as well as specific examples thereof, are intended to encompass both structural and functional equivalents thereof. Additionally, it is intended that such equivalents include both currently known equivalents as well as equivalents developed in the future, i.e., any elements developed that perform the same function, regardless of structure.  
         [0020]     Thus, for example, it will be appreciated by those skilled in the art that the diagrams herein represent conceptual views of illustrative structures embodying the principles of the invention.  
         [0021]     By way of additional theoretical background, we consider concurrent systems having a finite number of processes or threads where each thread is a deterministic sequential program written in a language such as C. As is known, threads may interact with each other using communication/synchronization objects like shared variables, locks and semiphores.  
         [0022]     Formally, we define a concurrent program CP as a tuple (T,V,R,s 0 ) where T={T 1 , . . . , T n } denotes a finite set of threads, V={v 1 , . . . , v m } a finite set of shared variables and synchronization objects with v i  taking on values from the set V i , R the transition relation and s 0 , the initial state of CP. Each thread T i  is represented by a control flow graph of the sequential program it executes, and is denoted by the pair (C i ,R), where C i  denotes the set of control locations of T i  and R i  its transition relation.  
         [0023]     A global state s of CP is a tuple:
 
( s[ 1 ], . . . s[n],v[ 1 ], . . . v[m ])ε S=C   1   × . . . ×C   n   ×V   1   × . . . ×V   m ;
 
 where s[i] represents the current control location of thread T i  and v [j] the current value of variable V j . The global state transition diagram of CP is defined to be the standard interleaved composition of the transition diagrams of the individual threads. Thus each global transition of CP results by firing a local transition of the form (a s ,g,u,b i ) where a i  and b i  are control location in some thread T i =(C i ,R i ) with (a i ,b i ) E R.; gi is a guard which is a Boolean-valued expression on the values of local variables of T i  and global variables in V; and u is a function that encodes how the value of each global variable and each local variable of T i  is updated. 
 
         [0024]     A transition t=(a i ,g,u,b i ) of thread T i  is enabled in state s iff s[i]=a i  but g need not be true in s, then we simply say that t is scheduled in s. We write  
       s   ⁢     →   t     ⁢     s   ′         
 
 to mean that the execution of t leads from states s to s′. Given a transition tεT, we use proc(t) to denote the process executing t. Finally, we note that each concurrent program CP with a global state space S defines the global transition system A g =(S,Δ,s 0 ), where Δ ⊂ S×S is the transition relation defined by  
           (     s   ,     s   ′       )     ∈     Δ   ⁢           ⁢   iff   ⁢           ⁢     ∃     t   ∈       T   ⁢     :     ⁢           ⁢   s     ⁢     →   t     ⁢     s   ′               ;       
 
 and s 0  is the initial state of CP. 
 
 Lock Synchronization Based Reductions 
 
         [0025]     We begin our discussion through the use of motivating examples. Consider a concurrent program CP shown as a program segment in  FIG. 1 . With reference to that  FIG. 1 , we see two threads T 1  and T 2  shown in  FIG. 1 ( a ) and  FIG. 1 ( b ), respectively. We note that x, which is the only variable shared among the two threads is unprotected at control location  5   b  and protected by lock lk at all other locations. Since x is unprotected at all locations where it is accessed, it does not satisfy the lock discipline mentioned earlier and (See, e.g., “ Model Checking Multi - Threaded Distributed JAVA Programs&#39; , authored by Scott D. Stoller and which appeared in International Journal On Software Tools For Technology Transfer, 4(1), pp. 71-91, October 2002) which will therefore force a context switch before locations  3   a  and  3   b.    
         [0026]     Consider a global state s of CP with threads T 1  and T 2  at control locations  3   a  and  3   b  respectively. A key observation is that starting at global state s of CP,  3   a  does not interfere with  3   b  and  5   b  even though  5   b  is unprotected. This is due to the fact that for T 2  to execute  3   b  it has to acquire lk currently held by T 1 . But in order for T 1  to release lk, it must first execute  3   a.    
         [0027]     Thus starting at s, CP is forced to execute  3   a  before  3   b . As a result no context switch is required before  3   a . However, in the global state s′ with T 1  and T 2  at control locations  3   a  and  5   b  respectively, the transitions  3   a  and  5   b  do interfere with each other thereby forcing a context switch before  3   a . As can be appreciated by those skilled in the art, even though shared variables need not follow a locking discipline globally, there are still identifiable portion of the state space where locking discipline is followed. Thus a context driven analysis allows us to define transactions locally—on-the-fly—where prior art methods—because of their reliance on global analysis—fail to do so.  
         [0028]     Taking this further, we can now show that transactions may be identified even in the absence of lock discipline—local or global. With reference now to  FIG. 2 , there is shown program segment threads T 1  and T 2  in  FIG. 2 ( a ) and  FIG. 2 ( b ) respectively each having unprotected access to x. We let CP be a concurrent program comprising these two threads T 1  and T 2  both sharing variable x as shown.  
         [0029]     Consider a global state s of CP with threads T 1  and T 2  in control locations  6   a  and  1   b , respectively. Observe that starting at s, the transitions at control locations  6   a  and  6   b  cannot interfere with each other even though they access the same shared variable x This is because in order for thread T 2  to reach location  6   b  from location  1   b  it has to traverse the local path  1   b ,  2   b ,  3   b ,  4   b ,  5   b , along which it has to acquire (and release) lock lk 1 . currently held by T 1 . In order for that to happen, T 1  must release lk 1  for which it must execute transition  6   a . As a result, transition  6   a  is forced to be executed before transition  6   b . Thus no context switch is required before location  6   a.    
         [0030]     One key observation to be made here is that even though disjoint sets of locks were held at locations  6   a  and  6   b , it was the set of locks that needed to be acquired by T 2  in order to transit from  1   b  to  6   b  (even though some of these locks were released before reaching  6   b ) that prevented  6   a  and  6   b  from interfering with each other. A traditional, prior-art, lockset-based analysis such as presented in [Sto02,FQ03] would treat  6   a  and  6   b  as conflicting transitions (as x does not follow locking discipline) and force a context switch before these locations.  
         [0031]     Consequently, those skilled in the art will recognize that a conflict analysis based on lock acquisition patterns according to the present invention is more refined than one based on locksets.  
         [0000]     Transactions VIA Persistent Sets  
         [0032]     We may now show how to integrate lock-pattern based on-the-fly transactions with partial order reduction in a transparent fashion by capturing the increased granularity of transitions due to transactions as a reduction in the sizes of the conditional stubborn sets of states. This is accomplished by ensuring that if in a global state s, a thread T i  is executing a transaction then, in the persistent set of s, we include only one transition, viz., the transition of T i  that fires next along the transaction being executed. This ensures that once the first transition of a transaction is executed, by a thread T i  then no other process can be scheduled unless all transitions of the transaction finish firing.  
         [0033]     State space reduction using partial order techniques is obtained by exploring from each individual state only those transitions that belong to a persistent set of that individual state instead of all the enabled transitions. Although there are many ways to compute persistent sets, a method of computing conditional stubborn sets usually generates those with small cardinality. For our purposes herein, we use standard terminology from the theory of partial order reductions and the algorithm for computing conditional stubborn sets (See, e.g., P. Godenfroid, “ Partial Order Methods For The Verification of Concurrent Programs: An Approach To The State Explosion Problem ”, LNCS 1032, Springer-Verlag, 1996) which we denote by Algo 1 .  
         [0034]     We begin by recalling the following definition:  
         [0035]     Might-be-first-to-interfere: Let op and op′ be two operations on the same object O and s be a reachable state. The relation op            s  op′ holds if there exists a sequence  
       s   =       s   1     ⁢     →     t   1       ⁢       s   2     ⁢     →     t   2       ⁢     …   ⁢     →     t   n       ⁢     s     n   +   1                 
 
 of transitions in A G  such that ∀ 1 ≦i&lt;n: ∀op″ on O used by t i : op and op′ are dependent in s n . 
 
         [0036]     For each local transition  
       a   ⁢     →   g     ⁢   b       
 
 of a thread, we let used(t) denote the set of operations on variables and synchronization objects executed during the execution of t. A conditional stubborn set of state s of A G  can then be calculated as follows: 
    1. Initialize T s ={t}, where t is some enabled transition in s.     2. For each  
       t   =       a   ⁢     →   g     ⁢   b     ∈     T   s           
   
 
         [0039]     (a) If t is disabled in s, 
        i. If T j =Proc(t) and s[j]≠a then add to T s  all transitions t′ of T j  of the form  
       c   ⁢     →     g   ′       ⁢   a       
     , or     ii. Choose a condition c j  in the guard g of t that evaluates to false in s; then, for all operations op used by t to evaluate c j , add to T s  all transitions t′ such that ∃op′ ε used (t′): op            s  op′       
 
         [0043]     (b) If t is enabled in s add to T s  all transitions t′ such that proc (t)≠proc(t′) and ∃op ε used (t), ∃op′ ε used (t′): op            s  op′ 
         [0044]     3 Repeat step 2 until no more transitions can be added in T s . Then return all transitions in T s . that are enabled in s.  
       Algo 1  for Computing Conditional Stubborn Sets  
       [0045]     In Algo 1  dependencies between transitions, arising out of operations on shared communication objects are captured using the            s  relation which captures for each operation op used by a transition in a state s which other operations might be first to interfere with op from the current state s. In practice, to avoid exploration of the state space of the program at hand, static analysis is employed in order to compute a relation,            s   st . which is an over-approximation of            s . Towards that end, we say that two operations op and op′ are statically dependent if they access a common shared variable such that at least one of the accesses is a write operation. Then            s   st , is defined as follows.  
         [0046]     Definition: Let op and op′ be two operations on a common shared variable and s is a reachable state of A G . The relation            s   st  op′ holds iff there exist distinct threads T i  and T j  such that there exists (1) a transition of T i  scheduled—but not necessarily enabled—at s using op, and (2) a local path  
         x   ⁢     :     ⁢           ⁢     p   0       ⁢     →     t   1       ⁢     …   ⁢     →     t   1       ⁢     p   n           
 
 of T j  such that p 0  is the local state of T j  in s, ∀ 1 ≦k ≦n: ∀op″ is used by t k : op and op″ are not statically dependent, t n  uses op′, and op and op′ are statically dependent. 
 
         [0047]     To incorporate on-the-fly transactions, we modify the above definition of            s   st  to obtain a new relation            s   lp   ⊂             s   st  by adding (in accordance with our discussion above), the extra constraint that none of the locks held by T i  in x is acquired (and possibly released) by T j  along x. Note that since            s   tp  is more constrained it enforces fewer dependencies between operations than            s   st  thus resulting in smaller conditional stubborn sets. As a result, certain interleavings are “weeded out” to produce the effect of executing transactions.  
         [0048]     Indeed—in the example given in  FIG. 2 —in global state s, if op and op′ are the operations x=0 and x=1 at locations  6   a  and  6   b , respectively, then op            s   st  op′ but           (op            s   lp  op′). Thus, using            s   lp  instead of            s   st  to compute conditional stubborn sets removes transition  1   b  from the conditional stubborn set s of thereby preventing a context switch before  6   a.    
         [0049]     Formally,            s   lp  is defined as follows.  
         [0050]     Definition (might-be-the-first-to-interfere-modulo-lock-acquisition) Let op and op′ be two operations on a common shared variable and s a reachable state of A G . The relation op            s   lp  op′ holds iff there exist distinct threads T i  and T j  such that there exist: (1) a transition of T i  scheduled (although not necessarily enabled) at s using op and (2) a local path  
         x   ⁢     :     ⁢           ⁢     p   0       ⁢     →     t   1       ⁢     …   ⁢     →     t   n       ⁢     p   n           
 
 of T j  such that ∀ 1 ≦k&lt;n : ∀op″ used b)y t k : op and op′ are not statically, dependent, t n  uses op′, and op and op′ are statically dependent and no lock held b T i  in s is acquired by T j  along x. 
 
         [0051]     Now, if we let Algo 2  be the result of replacing            s  in Algo 1  by            s   st  and Algo 3  the result of replacing            s   st  in line 2. (b) .i of Algo 2  by            s   lp . Then the following two results state that Algo 3  does advantageously compute a conditional stubborn set than is smaller than one computed by Algo 2 . Note however, that although we used a specific relation            s   st  for computing dependencies statically, one can of course incorporate on-the-fly transactions with any other implementation of            s  by merely adding the extra condition regarding lock acquisition patterns, as above.  
         [0052]     Theorem 1. All sets T s  that are computed by Algo 3  are conditional stubborn sets of s.  
         [0053]     Proof Sketch: Let  
       t   =     a   ⁢     →   g     ⁢   b         
 
 executed by thread T j  belong to T s . Let  
       w   =       s   1     ⁢     →     t   1       ⁢       s   2     ⁢     →     t   2       ⁢     …   ⁢     →     t   n       ⁢     s     n   +   1                 
 
 be a sequence of transitions of A G  such that t is dependent with t n  in s n . We need to show that at least one of t 1 , . . . , t n  is in T s . Without loss of generality, we may assume that for 1≦i&lt;n,t is independent with t i , in s i  and t n  is dependent with t in s n , else we can pick an appropriate prefix of w. 
 
         [0054]     First, we assume that t is disabled in s. Since t is disabled in s, and s n  is the first state along w in which t is dependent (with t n ), we have that t is enabled in s n+1 . Since t is disabled in s, either s[i]≠a, or a condition c in guard g evaluates to false in s. In the first case, since t is enabled in S n+1 , there exists a transition t j  fired along w, of the form d→a labeled with some guard g′. But then executing step 2. (a) .i of Algo 3  would cause t j  to be included in T s .  
         [0055]     In the second case, there exists a transition t j  that changes the value of c from false to true by changing the output of an operation op used to evaluate c, i.e., by performing an operation op′ dependent with op in s j l Let t   j  be the first such transition occurring along w. Clearly, op′ is statically dependent with op. By definition of            s   st , we have op            s   st  op′, and so t j εT s  by step 2. a. (ii).  
         [0056]     We may now consider the case where t is enabled in s. From the facts that: (i) for 1≦j ≦n−1, t is independent with t j  in s j ,and (ii) t is enabled in s, we have that for 1≦j ≦n−1, t is enabled in s j . This implies that the thread T i  does not execute any transition along w, otherwise—since T i  is deterministic—we conclude that t is the first transition that T i  executes along w.  
         [0057]     As can be appreciated, this would force T i  out of its current local state thereby disabling t and thereby contradicting the above observation. Note that here we assumed that executing a transition takes a process out of its current local state, i.e., there are no self loops in a program thread—which is a reasonable assumption for software programs.  
         [0058]     Now, since t and t n  are dependent in s n , it implies that ∃opεused(t),∃op′ εused(t n ):op and op′ are dependent in s n  and therefore are also statically dependent. If we let t j  be the first transition along w that uses an operation op″ dependent op. Note also that there does not exist a lock  1  held by T i  at s such that  1  has to be acquired before t j  is executed along w. Otherwise,  1  must first be released by T i  thus forcing T i  to execute a transition contradicting our observation made above that T i  does not execute any transition along w Thus we have op            s   lp  op″ and hence t j ε T s  by step 2.b. (i).  
         [0059]     Theorem 2. For all transitions t that are enabled in s, for all persistent sets Algo 2  that can be returned by Algo 2 , there exists a run of Algo 3  that returns a persistent set Algo 3 (t)⊂Algo 2 .  
         [0060]     Proof Sketch: From the definition of relation            s   lp , it follows that            s   lp  is included in            s   st . Thus the set T s  returned by Algo 3  is always a subset of the one returned by Algo 2  provided the same choices are made in case of nondetermination.  
         [0000]     Software Modeling for Concurrent C Programs  
         [0061]     Translating Individual Threads Into Circuits  
         [0062]     We may now describe how—using F-Soft—we first obtain a circuit-based model of each thread, under the assumption of bounded data and bounded control (recursion) (See, e.g., F. Ivancic et. al. “ Model Checking C Programs Using F-Soft ”, In ICCD, 2005). Briefly, we begin with a C program and apply a series of source-to-source transformations to simplify complex C expressionism into smaller but equivalent subsets of C. Next, all arrays and structs are “flattened” by replacing them with collections of simple scalar variables, aid then build ant internal memory representation of the program by assigning to each scalar variable a unique number representing its memory address.  
         [0063]     Variables that are adjacent in C program memory are given consecutive memory addresses in our model; which advantageously facilitates modeling of pointer arithmetic The heap is modeled as a finite array, by adding a simple implementation of malloc ( ) that returns pointers into this array.  
         [0064]     For handling pointer accesses we first perform a “points-to” analysis to determine the set of variables that a pointer variable can point to. Then, we convert each indirect memory access, through a pointer or an array reference, to a direct memory access. For example, if we determine that pointer p can point to variables a, b, . . . , z at a given program location: we rewrite a pointer read *(p+i) as a conditional expression of the form:
 
(( p+i )==&amp; a ? a :(( p+i )==&amp; b ? b : . . . )),
 
 where &amp;a,&amp;b, . . . are the numeric memory addresses we assigned to the variables a, b, . . . , respectively. 
 
         [0065]     Nonrecursive function calls are handled by inlining exactly once, and replacing that particular function&#39;s return by a set of goto-s conditioned upon the unique call site id stored on that function&#39;s entry. Bounded recursive functions are modeled by introducing a bounded call stack. While we aim for accurate modeling of all C, practical modeling requires making approximations.  
         [0066]     Accordingly, large arrays are truncated. Writes to elements above a certain index are ignored, and reads from these elements yield non-deterministic values. Floating-point values are approximated by modeling their integral parts only The simplified program includes scalar variables of simple types (Boolean, enumerated, integer). This is compiled using standard techniques into its control flow graph (CFG). T  
         [0067]     Those skilled in the art will recognize that the CFG representation can be viewed as a finite state machine with state vector (pc, V), where pc denotes an encoding of the basic blocks, and V is a vector of integer-valued program variables. We then construct symbolic transition relations for pc, and for each data variable appearing in the program. For pC, the transition relation reflects the guarded transitions between basic blocks in the CFG counter. For a data variable, the transition relation is built from expressions assigned to the variable in various blocks. Finally, we construct a symbolic representation of these transition relations resembling a hardware circuit. For the pc variable, we allocate ┐log N┌ latches, where N is the total number of basic blocks. For each C program variable, we allocate a vector of n latches, where n is the bit width of the variable. Al the end, we obtain a circuit-based model of each thread of the given concurrent program, where each variable of the thread is represented in terms of a vector of binary-valued latches and a Boolean next-state function (or relation) for each latch.  
         [0068]     Building The Circuit for the Concurrent Program  
         [0069]     Given the circuit C i  for each individual thread T i , we may now show how to get the circuit C for the concurrent program CP comprised of these threads. In the case where local variables with the same name occur in multiple threads, to ensure consistency we prefix the name of each local variable of thread T i  with thread i. Next, for each thread we introduce a gate execute_i indicating whether P i  has been scheduled to execute in the next step of CP or not.  
         [0070]     For each latch l, we let next-states i (l) denote the next state function of l in circuit C i . Then in circuit C, the next state value of latch thread_i_l corresponding to a local variable of thread T i , is defined to be next-state i (thread_i_l) if execute_i is true, and the current value of thread_i_l, otherwise. If, on the other hand, latch l corresponds to a shared variable, then next-state(l) is defined to be next-state i (l), where execute_i is true. Note that we need to ensure that execute_i is true for exactly one thread T 1 . Towards that end, we implement a scheduler which determines in each global state of CP which one of the signals execute_i is set, to true and thus determines the semantics of thread composition.  
         [0071]     Conditional Stubborn Sets Based Persistent Sets  
         [0072]     To incorporate partial order reduction, we need to ensure that from each global state s only transitions belonging to a conditional stubborn set of s are explored. We let R and R i  denote the transitions relations of CP and T 1 , respectively. If CP has n threads, we introduce the n-bit vector cstub which identities a conditional stubborn set for each global state s, i.e., in s,cstub i  is true for exactly those threads T i  such that the (unique) transition of T i —enabled at s—belongs to the same minimal conditional stubborn set of s. Then:  
         R   ⁡     (     s   ,     s   ′       )       =       ⩔     1   ≤   i   ≤   n       ⁢       (       (   execute_i   )     ⩓       cstub   i     ⁡     (   s   )       ⩓       R   i     ⁡     (     s   ,     s   ′       )         )     .           
 
         [0073]     The cstub vector may be computed as follows: 
    1 For each shared variable x and thread T i , we introduce a latch touch-now(T i ,x) which is true at control location pc i  of T i  iff T i  accesses x at control location pc i . This can be done via static analysis of the CFG of T i  by determining at which control locations x was accessed and taking a disjunction for those values of pc i .     2. For each shared variable x, and thread T i , introduce the latch touch-now-later(T i ,x), which is true at control location pc i . Thus, computing touch-now-later (T i ,x) involves deciding the reachability of pc′ j , and since it cannot be computed exactly without exploring the entire state space A G  of CP, we over-approximate it by performing a context-sensitive analysis of the control-flow graph of T j . We set touch-now-later-pair (T j ,x)to true in control pc j  if for some control pc′ j  in the control flow graph of T j ,x is accessed at pc′ j .     3 For distinct threads T i  and T j  the relation conflict i (j) is then defined as            xεv     sh   (touch−now(T i ,x)(pc i )         touch−now−later(T j ,x)(pc j )), where pc i  and pc j  are the control locations of T i  and T j , respectively, in the current global state and V sh  is the set of shared variables of CP.     4. Using a circuit to compute transitive closures, for each i, starting with J i ={i} we compute the closure of J i  under the conflict relation defined above.     5 We build a circuit to compute the index in such that the cardinality of J min  is the least among the sets J 1 , . . . , J n . Finally ∀ 1 ≦i≦n, set cstub i =1 iff iεJ min . Note that in the implementation we need to pick only one set with the least cardinality.    
 
         [0079]     Cycle Detection: We first identify sticky transitions for all potential global cycles. We then force a conflict for the process containing the sticky locations with all other processes via the encoding below.  
         [0080]     More particularly, we let sticky(pc) be a predicate evaluating to true iff location pc has been marked sticky. Then, for global state s, we define
 
conflict i ( j )=sticky ( pc   i )         (touch−now( T   i   ,x )( pc   i )         touch−now−later ( T   j   ,x )( pc   j ))
 
 where PC m  is tile current control location of T m  in s. In other words, if pc i  is sticky then thread T i  is said to conflict with all other threads. This implies that either a thread T k −with smaller conflict set J k —would be chosen for the persistent set computation or a full expansion would be forced. 
 
         [0081]     Those skilled in the art will now recognize that this reduction is sound, since any cycle in the global state space can be projected on to one or more local cycles in the control flow graph of the individual threads. By forcing a full expansion inside each (potential) local cycle with the help of sticky transitions, we advantageously ensure that there is no global cycle such that a thread transition is postponed at each state of the cycle. Therefore this encoding allows the model checker to explore a conservative over-approximation of the representative (minimal) set of interleavings of the given threads. Although the reduced model remains sound, the number of interleavings considered may decrease dramatically with the number of annotated sticky transitions.  
         [0082]     Encoding Lock Pattern Based Reduction  
         [0083]     In order to incorporate transactions on-the-fly, we advantageously have augmented the predicate touch-now-later, to generate the new predicate touch-know-later-LS that also includes lock acquisition pattern information. For control locations pc i  and pc′ i  of thread T i , we let paths (pc i , pc′ i ) denote the set of paths in the CFG of T i  starting from pc i  that may reach pc′ i . For each π ε paths (pc i , pc′ i ) of T i , let lockPred(π) be a formula denoting the set of locks acquired (and possibly released) among π, e.g., lk 1 =T 1           lk 2 =T i .  
         [0084]     Let touch−now−later−pair(T j ,x)(pc′)         AP x (pc j ,cp′ j ), where AP x (pc i ,pc′ i )=           πεpaths(pc     i     ,pc′     i   ) lockPred(π). Let CLP(T i ,s) denote a formula encoding the ownership of locks T i  in global state s. Then the relation touch−now−LS(T i ,x) is obtained from touch−now−later−pair(T i ,x) by quantifying out pc′ i  in conjunction with the CLP(T i ,s),i.e., touch−now−LS(T i ,x)(pc i )=(∃pc′ i touch−now−later−pair(T i ,x)(pc i , pc′ i ))         CLP(T i ,s)  
         [0085]     Therefore, touch−now−LS(T i ,x)(pc i ) is true if there is a location pc′ i  accessing a shared variable x that is reachable from pc i  via a local path π in T i  such that no lock held in s is acquired along π. We evaluate lockPred (π) using a context sensitive static analysis of the CFG of T i .  
         [0086]     With the theoretical basis in place we may now summarize our inventive method which is shown in a block diagram in  FIG. 3 . In particular, and with reference to that figure, a number of individual threads  310 [1] . . .  310 [ n ] which comprise a concurrent multi-threaded program are reduced into a like number of reduced threads  320 [1] . . .  320 [ n ] through a static analysis including a number of a variety of known methods including slicing, range analysis and constant folding. These reduced threads are further translated into a circuit-based (finate state) model  330 [1] . . .  330 [ n ] for each individual thread respectively where each variable of the thread is represented in terms fo a vector of binary-valued latches and a Boolean next-state function (or relation) for each latch.  
         [0087]     The individual circuits  330 [1] . . .  330 [ n ] are combined by a scheduler into a single circuit for the entire concurrent program to which constraints are added  350  for partial order reduction, on-the-fly lockset reduction, acquisition history reduction and/or synchronous execution and constraints are added. Finally, the circuit is verified using symbolic model checking  360 .  
         [0088]     The Daisy Case Study  
         [0089]     We have employed our method of the present invention to find bugs in the Daisy file system which those skilled in the art will recognize as a benchmark for analyzing the efficacy of different concurrent program verification methodologies for verifying concurrent programs. Daisy is a Java implementation of a toy file system where each file is allocated a unique inode that stores the file parameters and a unique block which stores data. One interesting feature of Daisy is that it has fine grained locking in that access to each file, inode or block is guarded by a dedicated lock. Moreover, the acquire and release of each of these locks is guarded by a ‘token’ lock. Conseqently control locations in the program might possibly have multiple open locks and furthermore the acquire and release of a given lock can occur in different procedures.  
         [0090]     Currently F-Soft only accepts programs written in C se we first manually translate the Daisy code which is written in Java into C. Furthermore, to reduce the model sizes, we truncated the sizes of the data structures modeling the disk, inodes, blocks, file names. etc., which were not relevant to the race conditions we checked, resulting in a sound and complete small-domain reduction. We have shown the existence of the race conditions described below and noted in the art.  
         [0091]     The efficacy of our techniques can be evaluated from the fact that our model checking methodology according to the present invention is able to detect these race conditions in Daisy in a fully automatic fashion directly on the source code without any code structuring/abstractions beyond redefining the constants as discussed above.  
         [0092]     Daisy maintains an allocation area where for each block in the file system a bit is assigned 0 or 1 accordingly as the block has been allocated to a file or not. But each disk operation reads/writes an entire byte. Two threads accessing two different files might access two different blocks. However since bytes are not guarded by locks in order to set their allocation bits these two different threads may access the same byte in the allocation block containing the allocation bit for each of these locks thus setting up a race condition.  
         [0093]     The verification statistics we observed are as follows: We ran our experiments on a machine with an Intel Pentium4 3.20 GHz processor and 2 GB RAM. Each run was given a timeout of 2 days and had a memout of 2 GB. Witnesses for the above race condition were found in two cases, those corresponding to blocks  0  and  1 , and those due to blocks  1  and  2 . In sharp contrast, when using purely interleaved scheduling, we failed to find either witness because of a “memout” at depth  15 .  
         [0094]     When only partial order reduction was employed, was found using SAT-based BMC at unroll depth  122  in 36707 sec and 999 MB while incorporating on-the-fly transactions drastically reduced the time and memory usage to 1283 sec and 122 MB respectively The second witness was found at depth  151 . Using partial order reduction techniques alone took 145176 sec and 1870 MB, while adding transactions reduced ii to 5925 see and 902 MB.  
         [0095]     In Daisy reading/writing a particular byte on the disk is broken down into two operations: a seek operation that mimics the positioning of the head and a read/write operation that transfers the actual data. Due to this separation between seeking and data transfer a race condition may occur. For example, reading two disk locations, say n and m, we must make sure that seek(n) is followed by read(n) without seen(n) or read(n) scheduled in between. In this case a witness was found at depth  48 . Using partial order reduction alone took 2.99 see and 5.7 MB while adding transactions reduced it to 2.89 sec and 5.5 MB. For this example also BMC on the completely interleaved model failed to find a witness because of a memout at depth  20   
         [0096]     Advantageously, and as can be readily appreciated by those skilled in the art—for deep bugs techniques that leverage the use of on-the-fly transactions combined with partial order reduction greatly outperform those which use only partial order reduction—both in terms of time taken and memory used.  
         [0097]     At this point, while we have discussed and described our invention using some specific examples, those skilled in the art will recognize that my teachings are not so limited. Accordingly, our invention should be only limited by the scope of the claims attached hereto.