Same Engine, Multiple Gears: Parallelizing Fixpoint Iteration at Different Granularities (Extended Version)

2026-02-06

AI Summary

This work addresses the challenge of efficiently parallelizing fixed-point iterations in static analysis, which is hindered by rigid, fixed-granularity task decomposition. To overcome this limitation, the paper proposes a parameterized parallel fixed-point engine that, for the first time, supports dynamic switching of task granularity and unifies two prevailing parallel paradigms—on-the-fly sharing and independent state exploration. The engine extends the top-down solver TD with thread-safe hash tables and a publish/subscribe mechanism, and is integrated into the Goblint framework. Experimental evaluation on large real-world programs demonstrates significant improvements in analysis efficiency, thereby validating the effectiveness of the proposed multi-granularity parallelization strategy.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Data Mining & Knowledge Management: Scalability, Parallel & Distributed Systems
• Search and Optimization: Sampling/Simulation-based Search

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Search and Retrieval-Augmented AI: Efficiency and scalability of Web search engines
• Security and Privacy: Large-scale security measurements

Abstract

Fixpoint iteration constitutes the algorithmic core of static analyzers. Parallelizing the fixpoint engine can significantly reduce analysis times. Previous approaches typically fix the granularity of tasks upfront, e.g., at the level of program threads or procedures - yielding an engine permanently stuck in one gear. Instead, we propose to parallelize a generic fixpoint engine in a way that is parametric in the task granularity - meaning that our engine can be run in different gears. We build on the top-down solver TD, extended with support for mixed-flow sensitivity, and realize two competing philosophies for parallelization, both building on a task pool that schedules tasks to a fixed number of workers. The nature of tasks differs between the philosophies. In the immediate approach, all tasks access a single thread-safe hash table maintaining solver state, while in the independent approach, each task has its own state and exchanges data with other tasks via a publish/subscribe data structure. We have equipped the fixpoint engine of the static analysis framework Goblint with implementations following both philosophies and report on our results for large real-world programs.

Problem

• fixpoint iteration
• static analysis
• parallelization
• task granularity
• static analyzers

Innovation

• fixpoint iteration
• parallelization
• task granularity
• static analysis
• mixed-flow sensitivity