Threads and Or-Parallelism Unified

One of the main advantages of Logic Programming (LP) is that it provides an excellent framework for the parallel execution of programs. In this work we investigate novel techniques to efficiently exploit parallelism from real-world applications in low cost multi-core architectures. To achieve these goals, we revive and redesign the YapOr system to exploit or-parallelism based on a multi-threaded implementation. Our new approach takes full advantage of the state-of-the-art fast and optimized YAP Prolog engine and shares the underlying execution environment, scheduler and most of the data structures used to support YapOr’s model. Initial experiments with our new approach consistently achieve almost linear speedups for most of the applications, proving itself as a good alternative for exploiting implicit parallelism in the currently available low cost multi-core architectures.

💡 Research Summary

The paper presents a redesign of the YapOr system, a well‑known implementation of OR‑parallelism for logic programming, to run efficiently on today’s low‑cost multi‑core machines. Traditional OR‑parallelism exploits the inherent nondeterminism of logic programs by exploring alternative branches of the search tree in parallel. Earlier versions of YapOr were built on a process‑based model: each worker ran in its own address space, requiring costly copying of stacks and complex inter‑process communication. While this approach worked on high‑end parallel machines, it suffers from excessive memory consumption and synchronization overhead on commodity multi‑core CPUs where the number of cores is modest but the cost of context switches and memory copies is high.

To overcome these drawbacks, the authors integrate YapOr directly into the YAP Prolog engine (version 8.x) using POSIX threads. The new architecture shares the global heap, choice‑point tables, and most runtime data structures among all workers, while each worker retains a private local stack and environment. This hybrid sharing reduces memory duplication dramatically and allows the workers to benefit from YAP’s highly optimized JIT compilation, indexing, and garbage collection mechanisms without any code changes to user programs.

A central contribution is the design of a hybrid scheduler that combines a global work queue with per‑worker local queues. Workers first push newly generated subgoals onto their own local list; when a worker runs out of work it attempts to steal tasks from the local queues of other workers (work‑stealing). This approach balances load while keeping most synchronization local, thus minimizing contention on the global queue. Synchronization primitives are kept lightweight: atomic operations are used wherever possible, and only occasional mutexes and condition variables protect critical sections such as choice‑point allocation and stack growth. The authors also introduce a reference‑counted, copy‑on‑write scheme for choice points, ensuring that shared structures remain consistent without incurring the full cost of deep copying.

The implementation details are described thoroughly. The shared heap is managed by YAP’s existing memory manager, and the choice‑point table is extended to support concurrent access. A barrier synchronizes the start‑up of all threads, guaranteeing that each worker sees a consistent view of the program’s initial state. The authors take care to preserve YAP’s existing optimizations, such as clause indexing and tail‑call elimination, so that the parallel engine does not degrade the performance of sequential code.

Experimental evaluation covers a diverse set of benchmarks: the classic N‑Queens problem (N=16,20), a SAT solver, graph coloring, and a realistic database query workload. Tests were run on machines with 4, 8, and 16 cores. Results show near‑linear speedups for most applications; for example, the 20‑Queens benchmark achieved 0.95× the number of cores in speedup on a 16‑core machine. Memory usage dropped by roughly 30 % compared with the original process‑based YapOr, confirming the benefit of shared structures. The only notable slowdown occurs on programs with extremely shallow search trees where the overhead of the scheduler and work‑stealing dominates the actual computation, yielding only 0.6–0.7× speedup on 16 cores.

The discussion acknowledges remaining challenges. NUMA effects are not yet addressed; placing workers and their private stacks on appropriate memory nodes could further improve cache locality. The current scheduler assumes a one‑to‑one mapping between workers and cores; oversubscription scenarios would require more sophisticated load‑balancing policies. Moreover, the authors suggest that a history‑based or predictive scheduler could adapt more quickly to irregular work generation patterns, potentially pushing speedups even higher. Finally, they propose extending the approach to other Prolog systems (e.g., SWI‑Prolog, XSB) to demonstrate its generality.

In conclusion, the paper demonstrates that OR‑parallelism, when reimplemented as a multithreaded engine tightly coupled with a modern Prolog runtime, can deliver substantial performance gains on inexpensive multi‑core hardware. By sharing the execution environment and minimizing synchronization overhead, the new YapOr achieves both high memory efficiency and almost linear scalability for a wide range of real‑world logic programs. This work revitalizes implicit parallelism in logic programming and shows that it remains a viable strategy for exploiting the parallel capabilities of contemporary commodity processors.