SAT, SMT and QBF Solving in a Multi-Core Environment

Transcription

1 SAT, SMT and QBF Solving in a Multi-Core Environment Bernd Becker Tobias Schubert Faculty of Engineering, Albert-Ludwigs-University Freiburg, Freiburg im Breisgau, Germany {becker schubert}@informatik.uni-freiburg.de May 20, 2009 Abstract Recent trends in hardware design towards multi-core and multiprocessor systems call for the development of dedicated parallel algorithms in order to exploit the full potential of these architectures. We review recent work in this direction, put an emphasis on our own contributions and point out future challenges. Extended Abstract SAT- and SMT-solvers represent core components of hardware- and softwareverification tools. Verification quality and thus product quality significantly depends on the efficacy and efficiency of these solvers. Building upon the success of SAT- and SMT-solvers, the research community has begun to also reconsider the more general (but also more complicated) Quantified Boolean Formula (QBF) domain. The effectiveness and efficiency of modern SAT-solvers is e.g. demonstrated by the fact that they are able to tackle Boolean satisfiability problems with hundreds of thousands of variables (or sometimes even more). However, the last few years have shown two trends: first, the performance This work was partly supported by the German Research Council (DFG) as part of the Transregional Collaborative Research Center Automatic Verification and Analysis of Complex Systems (SFB/TR 14 AVACS). See for more information. 1

2 gains achieved by the SAT community in the field of sequential SAT solving are getting marginal, as it becomes harder and harder to optimize current algorithms even more. As a result, many of the challenging problem instances are still unsolvable by any sequential SAT-solver within a reasonable time frame. Second, many chip manufacturers have turned from single-core to multi-core designs as a way to increase the performance of their processors as gains in processor frequency have stalled. Companies such as AMD, IBM, Intel, and SUN now produce CPUs that contain four or more cores per processor. Putting these two observations together, a new generation of parallel SAT solvers is needed to utilize the enormous potential of multi-core processors and multi-cpu workstations and by this to reach the next performance level of modern SAT solving. And this argument is valid in a similar way for SMT- and QBF-solver. SAT As well known, the propositional satisfiability problem poses the question if a propositional formula is satisfiable, i. e., if there is an assignment mapping values to the variables in the formula such that the formula evaluates to true. SAT-solvers are devoted to solve such questions. In the last decade we could observe a massive increase in the efficiency of (sequential) SAT-solvers. This success, which led to industrial acceptance and employment, was mostly due to new efficient heuristics for and optimizations of the sequential SATsolving algorithms. The most prominent examples are non-chronological backtracking [?], conflict-driven learning [?], novel decision heuristics [?,?], restarts [?], and powerful preprocessing techniques [?,?]. Moreover, the implementations of these methods have been improved by considering the underlying hardware environment that was running the SAT solver. For example, zchaff introduced the concept of watched literals, that effectively uses the cache memory of modern CPUs [?]. Research on parallelizing SAT algorithms can be traced back to at least 1994, where Böhm and Speckenmeyer introduced an approach for a transputer system with up to 256 processors [?]. In subsequent years, a number of more advanced implementations have been published. Typically, a parallel SAT solver consists of a collection of sequential SAT procedures, solving a problem in parallel. We distinguish two main strategies: the search space splitting (SSS) approach, where parts of the search space are explored in parallel. The most widely used way adopts a Dynamic Search Space Partitioning technique proposed by Zhang et al. in 1997 [?], which is based on the concept of Guiding Paths (GP). A GP is defined as a path in the search 2

3 tree from the root (no variables assigned) to the current node (some variables assigned). Intuitively, a GP describes the current state of the search process. The second strategy is the portfolio (PF) approach, where the same problem is tackled in parallel by different algorithms, e.g. based on different parameter settings. Independent of the overall strategy, to compare the various designs, it is reasonable to focus on how the different solvers implement the exchange of conflict clauses. There is obviously a trade-off between the advantage of sharing conflict clauses to prune the search space and the communication overhead to broadcast this information, making knowledge sharing one of most critical points when designing a parallel SAT solver. 1. The first and most common way to support conflict clause sharing is by using message passing, typically according to the Message Passing Interface standard [?]. This concept has been used in various approaches [?,?,?,?], all of them showing that significant speedup can be achieved. But due to the overhead associated with sending messages via some kind of network, typically only short clauses consisting of a very few literals are sent. Additionally, the clauses are often sent in bundles, on one hand minimizing the communication overhead, but on the other hand introducing more latency into the clause sharing system. For example, in GridSAT [?] only clauses with at most three literals are exchanged between the different SAT solving processes, which is also the setup in PaMiraXT (on the client s side) [?]. 2. Another method maintains a shared Conflict Clause Database to share clauses, which has to be accompanied by a thread-based design. In this system, each thread occasionally sends well-suited clauses to this database (again, according to some criteria, e.g. the clause length), while also checking to see if new conflict clauses have been added by other SAT solving threads. PaSAT [?] 1 and ysat [?] both use this concept. The concept of a shared Conflict Clause Database is typically not as scalable as message passing, but allows longer clauses to be shared without overwhelming the entire search process with communication related tasks. This system also reduces the latency within the clause sharing mechanism. 1 Note, that different versions of PaSAT have been published in the past. Besides the one discussed here, there is also a version based on an the PF-approach design as well as a version using mobile agents when executed on a workstation cluster [?,?]. 3

4 3. The third method is the shared memory clause database design that MiraXT (and by this the clients of PaMiraXT) use. Compared to ysat, this approach goes one step further by maintaining only one physical copy of each clause, regardless of it is a conflict clause or a clause of the original CNF formula. All conflict clauses are added to this Shared Clause Database, and each SAT solving thread dynamically selects which clauses it wants to use. This is the reverse to the concept mentioned before, in which each thread chooses which clauses it wants to offer or send to the other threads by integrating them into the Conflict Clause Database. As an example, in PaSAT only clauses with at most five literals will be shared. In contrast to this, PaMiraXT allows each thread to check all available conflict clauses and to consider its current status when selecting helpful clauses. A thread can now decide to add very long clauses that will force implications or conflicts, while ignoring short clauses that are already fulfilled by the thread s variable assignments. This design takes full advantage of the low latency and high bandwidth a shared memory database provides. We present some more details on the parallel SAT solver PaMiraXT that has been optimized to run efficiently on many different hardware platforms. The solver consists of two layers of parallelism. The first level is based on MiraXT, a thread-based implementation optimized for shared memory multiprocessor systems (multi-core and/or multi-cpu). To be able to run our solver not only on shared memory multiprocessor systems, but also on classical workstation clusters, a second layer of parallelism ist added, resulting in the entire parallel SAT algorithm PaMiraXT. The overall design follows a master/client model, where copies of MiraXT are run on different workstations of a particular cluster (acting as clients). For communication purpose we added a separate master process, responsible for exchanging status signals, unevaluated subproblems, and conflict clauses between the clients. Furthermore we discuss recent developments in particular with repsect to preprocessing. Experimental results together with a discussion of other parallel SAT-solvers conclude this section. SMT Extending the propositional logic by embedding some theories, e. g., equalities, uninterpreted functions, or theories over the reals, results in powerful logics and leads to the satisfiability modulo theories (SMT) problem. SMT-solvers find applications in several verification domains, for example 4

5 in bounded model checking of hybrid systems [?,?,?]. In principle, the SSS-approach as well as the PF-approach can be adapted also to the SMT scenario, though in detail search space splitting and conflict clause sharing turns out to be intricate. We provide some details on a parallel SMT-solver called Picoso [?] for the first order theory of the reals extended with transcendental functions. This is a very powerful logic and allows to formalize properties of systems with continuous components, like this is the case for hybrid systems. Picoso is realised with the SSS-approach. To our best knowledge, Picoso is the only published parallel SMT-solver (for the undecidable domain of non-linear constraints involving transcendental functions). The algorithmic core of Picoso is based on the interval constraint solver isat [?]. Currently we are also exploring the PF-approach. First experimental results will be presented. QBF While many QBF solvers are still based on the DPLL algorithm [?], they have advanced considerably in recent years. For instance, some QBF algorithm specific advances include conflict and solution analysis with nonchronological backtracking [?,?,?,?], and preprocessing [?,?]. Modern QBF solvers must combine all these new ideas into an efficient implementation to be competitive. Future QBF solvers, similar to the case of SAT- and SMT-solvers, must harness the potential of multi-core and multi-processor systems if they wish to provide leading edge performance. Similar as in the SMT scenario SSS- and PF-approaches seem feasible but have to be adapted to include the features of modern sequential QBF-solvers to allow e.g. conflict clause and solution cube sharing. The development in this domain is just starting. Before 2009, there has has been only one parallel QBF solver that we are aware of, called PQSOLVE [?]. PQSOLVE was based on the basic DPLL algorithm, without conflict analysis, solution analysis, watched literals, and many other advanced techniques used in QBF solvers today. Recently, the threaded parallel SAT solver MiraXT [?] was modified so that it could directly handle QBF formulas [?]. QMiraXT provides a tight integration of threads to allow significantly more knowledge sharing than an MPI design. Subsequently, PaQuBE [?] builds upon the ideas of QMiraXT and, on the basis of QuBE [?], provides a master/slave MPI design, making it far more scalable than QMiraXT allowing it to take advantage of entire clusters or grids. We finish with first encouraging results on a PF-approach for a rewriting based QBF-solver in combination with the search-based solver 5

6 QMiraXT. 6