REU 2007 Par Sat A Parallel SAT Solver

REU 2007 -Par. Sat: A Parallel SAT Solver Christopher Earl, Mentor: Dr. Hao Zheng Introduction The Boolean Satisfiability Problem (SAT) was the first problem to be proven NP-Complete over thirty-five years ago by Cooke. Since then not only has it been widely studied without success to develop a polynomial time algorithm, but there have been hundreds of problems found that can be reduced to SAT, ranging from optimizing microchip design to problems in graph theory such as the Traveling Salesman Problem. Because of the broad range of applications of SAT to both theory and practical applications, it cannot be ignored. While in general SAT is intractable, many instances can be solved very quickly. The Satisfiability Problem is a decision problem wherein given a Boolean formula, determine if it is satisfiable or not. To be satisfiable, there must be a way to set some or all the variables in the Boolean formula such that the entire formula simplifies to true. Over the years, there have been many programs designed to solve instances of SAT sequentially and in recent years in parallel as well. Most programs are based upon the DPLL algorithm, which searches through the decision tree and backtracks where possible. Programs designed to work in parallel have ranged from new designs that embrace parallelism throughout the program to those that use sequential programs as “blackboxes” and split the given instance into partitions. In this project Par. Sat, a parallel solver using pthreads and based on the sequential program Mini. Sat, was developed, implemented, and tested. Mini. Sat currently is one of the fastest SAT solvers available, having received first place in both the International SAT Competition 2005 and SAT-Race 2006 and third place in the International SAT Competition 2007. Methodology and Implementation In Par. Sat depending on the options set, reduction based upon the pure literal rule can be done immediately after reading in all the clauses to potentially remove some clauses and simplify others. The pure literal rule is the realization that any variable that appears in the clause database in either its positive or its negative form can be set true or false respectively to satisfy all the clauses in which that variable appears. Most current solvers do not reduce based on the pure literal rule because of the overhead costs and the fact that there may be reduction possible on a given instance. Par. Sat then solves a given instance in one of several ways based upon the options set. It can run Mini. Sat in its original form, or it can sequentially or in parallel run subdivisions of the given problem. Par. Sat subdivides the given instance of SAT into 2 k partitions, where k is a given number of variables. Each partition is based upon one possible setting of the chosen k variables. Currently the only method of choosing variables is random selection with equal probability for all variables that appear in the formula. Whether run sequentially or in parallel, Par. Sat stops running subdivisions once one subdivision finds that the given clause database is satisfiable. Because of the way Par. Sat was implemented, changing the “blackbox” Mini. Sat to another sequential solver is a rather straightforward process that allows for new faster sequential solvers to be quickly made into a parallel version. Results and Conclusions So far testing has been limited to around 50 benchmarks from the test suites of SAT-Race 2006. The times in the tables above are recorded in seconds. The time limit for all tests was set to 1800 seconds (30 minutes). Mini. Sat was run with all default options. Seq. Sat refers to Par. Sat run in sequential mode. Both Seq. Sat and Par. Sat were run partitioned on one variable and reducing based upon the pure literal rule. In general based upon these tests, the overhead associated with Par. Sat’s pure literal rule reduction and thread management slow down Par. Sat to keep it roughly on par with Mini. Sat but considerable slow down Seq. Sat. The instances velev-pipe-uns-1. 1 -07. cnf and simon-mixed-s 02 bis-05. cnf in Test Suite 1 are a good examples of the savings that Par. Sat can have over Mini. Sat, but there are many examples of other instances such as grieu -vmpc-s 05 -05 s. cnf and manol-pipe-g 10 ni. cnf where Mini. Sat outperforms Par. Sat by a considerable margin. From the testing do so far, Par. Sat clearly shows potential, especially on satisfiable instances because Par. Sat checks multiple parts of the decision tree at once and so has more opportunity to find solutions. Seq. Sat as expected does lags behind Mini. Sat because it shares most of the same overhead cost with Par. Sat without having its advantage of running multiple threads at once. Department of Computer Science & Engineering