[Paper Review] Scalable Proof Producing Multi-Threaded SAT Solving with Gimsatul through Sharing instead of Copying Clauses

Mathias Fleury, Armin Biere|arXiv (Cornell University)|Jul 27, 2022

Logic, programming, and type systems4 citations

TL;DR

This paper presents Gimsatul, a scalable, proof-producing multi-threaded SAT solver that physically shares clauses across threads via pointers instead of copying them, significantly reducing memory usage and proof size. The approach enables linear scalability with thread count and produces DRUP/DRAT proofs nearly as compact as single-threaded runs, even with multiple threads.

ABSTRACT

We give a first account of our new parallel SAT solver Gimsatul. Its key feature is to share clauses physically in memory instead of copying them, which is the method of other state-of-the-art multi-threaded SAT solvers to exchange clauses logically. Our approach keeps information about which literals are watched in a clause local to a solving thread but shares the actual immutable literals of a clause globally among all solving threads. This design gives quite remarkable parallel scalability, allows aggressive clause sharing while keeping memory usage low and produces more compact proofs.

Motivation & Objective

• To address the high memory overhead and large proof sizes caused by clause copying in parallel SAT solvers.
• To enable efficient, scalable multi-threaded SAT solving with proof production, a requirement in the main track of the SAT Competition.
• To reduce proof size and checking time by sharing clauses globally instead of duplicating them in proofs.
• To design a SAT solver architecture that supports physical clause sharing without modifying existing proof checkers.
• To explore whether physical clause sharing leads to more compact proofs and better parallel scalability than traditional clause copying.

Proposed method

• Physically share clause data structures across threads using pointers instead of copying literals, maintaining shared immutable clause content.
• Keep watched literals local per thread while sharing the actual clause content globally, avoiding duplication in memory and proof logs.
• Use atomic reference counting via C11 stdatomic.h to safely manage shared clause lifetimes across threads.
• Implement a lock-free fast path for clause exchange and use Pthreads for thread management, condition variables, and synchronization.
• Integrate sequential inprocessing by consolidating irredundant clauses back to a single solver instance to maintain correctness.
• Log proofs in DRUP/DRAT format with shared clauses, avoiding redundant clause duplication across threads.

Experimental results

Research questions

• RQ1 Does physical clause sharing reduce memory usage and proof size in multi-threaded SAT solving compared to clause copying?
• RQ2 Can physical clause sharing enable linear scalability in multi-threaded SAT solving while maintaining proof production?
• RQ3 How does proof size and checking time compare between physically shared clauses and duplicated clauses in proofs?
• RQ4 Can proof checkers like drat-trim efficiently handle proofs from parallel solvers with shared clauses?
• RQ5 What impact does clause sharing have on the performance and correctness of proof-producing SAT solvers?

Key findings

• Gimsatul achieves linear scalability with the number of threads, demonstrating strong performance gains in multi-threaded environments.
• Proof size remains nearly constant across different thread counts, with minimal increase even at 16 threads, indicating effective sharing.
• Proofs generated with physical clause sharing are significantly smaller than those with clause duplication, especially at higher thread counts.
• Proof checking time with drat-trim is reduced when using shared clauses, though still slower than single-threaded checking due to lack of context awareness.
• The 2-thread configuration produced larger proofs than 1 or 4 threads, suggesting suboptimal portfolio strategy rather than a flaw in the sharing mechanism.
• The approach enables compact proofs independent of thread count, showing that clause sharing reduces redundant proof steps.