Parallel Pointer Analysis with CFL-Reachability

Su, Yu; Ye, Ding; Xue, Jingling

doi:10.1109/icpp.2014.54

Cited by 26 publications

(6 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Parallelization is an important aspect of the complexity of a problem. In the case of APA, this is further motivated by a multitude of parallel implementations [Blaß and Philippsen 2019;Liu et al 2019;Mendez-Lojo et al 2012;Méndez-Lojo et al 2010;Su et al 2014;Wang et al 2017]. The question is thus whether APA is effectively parallelizable.…”

Section: Summary Of Main Resultsmentioning

confidence: 99%

“…Parallelization. The demand for high-performance static analyses has lead various researchers to implement parallel solvers of APA [Blaß and Philippsen 2019;Liu et al 2019;Mendez-Lojo et al 2012;Méndez-Lojo et al 2010;Su et al 2014;Wang et al 2017]. Despite their practical performance, the parallelizability of APA has remained open on the theoretical level.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

The fine-grained and parallel complexity of andersen’s pointer analysis

Mathiasen

Pavlogiannis

2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Pointer analysis is one of the fundamental problems in static program analysis. Given a set of pointers, the task is to produce a useful over-approximation of the memory locations that each pointer may point-to at runtime. The most common formulation is Andersen’s Pointer Analysis (APA), defined as an inclusion-based set of m pointer constraints over a set of n pointers. Scalability is extremely important, as points-to information is a prerequisite to many other components in the static-analysis pipeline. Existing algorithms solve APA in O ( n 2 · m ) time, while it has been conjectured that the problem has no truly sub-cubic algorithm, with a proof so far having remained elusive. It is also well-known that APA can be solved in O ( n 2 ) time under certain sparsity conditions that hold naturally in some settings. Besides these simple bounds, the complexity of the problem has remained poorly understood. In this work we draw a rich fine-grained and parallel complexity landscape of APA, and present upper and lower bounds. First, we establish an O ( n 3 ) upper-bound for general APA, improving over O ( n 2 · m ) as n = O ( m ). Second, we show that even on-demand APA (“may a specific pointer a point to a specific location b ?”) has an Ω( n 3 ) (combinatorial) lower bound under standard complexity-theoretic hypotheses. This formally establishes the long-conjectured “cubic bottleneck” of APA, and shows that our O ( n 3 )-time algorithm is optimal. Third, we show that under mild restrictions, APA is solvable in Õ( n ω ) time, where ω<2.373 is the matrix-multiplication exponent. It is believed that ω=2+ o (1), in which case this bound becomes quadratic. Fourth, we show that even under such restrictions, even the on-demand problem has an Ω( n 2 ) lower bound under standard complexity-theoretic hypotheses, and hence our algorithm is optimal when ω=2+ o (1). Fifth, we study the parallelizability of APA and establish lower and upper bounds: (i) in general, the problem is P-complete and hence unlikely parallelizable, whereas (ii) under mild restrictions, the problem is parallelizable. Our theoretical treatment formalizes several insights that can lead to practical improvements in the future.

show abstract

Section: Summary Of Main Resultsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

The fine-grained and parallel complexity of andersen’s pointer analysis

Mathiasen

Pavlogiannis

2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…There are also several implementations of pointer analysis on multicore CPU systems, targeting either C or Java programs, with different field-, flow-or context-sensitivities [21], [35], [36], [37]. These implementations have achieved various speedups (2.6X -16.2X) over the corresponding sequential analysis.…”

Section: Parallel Pointer Analysismentioning

confidence: 96%

An Efficient GPU Implementation of Inclusion-Based Pointer Analysis

Su¹,

Ye²,

Xue³

et al. 2016

IEEE Trans. Parallel Distrib. Syst.

Self Cite

View full text Add to dashboard Cite

We present an efficient GPU implementation of Andersen's whole-program inclusion-based pointer analysis, a fundamental analysis on which many others are based, including optimising compilers, bug detection and security analyses. Andersen's algorithm makes extensive modifications to the graph that represents the pointer-manipulating statements in a program. These modifications are highly irregular, input-dependent and statically unpredictable, making it much more challenging to balance such graph workloads across a multitude of GPU cores than those dealt with by traditional graph algorithms such as DFS and BFS. To parallelise Andersen's analysis efficiently on GPUs, we introduce an imbalance-aware workload partitioning scheme that divides its workload dynamically among the concurrent warps, initially in a warp-centric manner (during the coarse-grain stage) but later switches to a task-pool-based model when a workload imbalance is detected (during the fine-grain stage). We improve further its performance by using an adaptive group propagation scheme to reduce some redundant traversals. For a set of 14 C benchmarks evaluated, our parallel implementation of Andersen's analysis achieves a significant speedup of 46% on average over the state-of-the art on an NVIDIA Tesla K20c GPU.

show abstract

“…Graspan is not a generic abstract interpreter, and solves data-flow analyses in the IFDS framework [Reps et al 1995]. Su et al [2014] describe a parallel points-to analysis via CFL-reachability. Garbervetsky et al [2017] use an actor-model to implement distributed call-graph analysis.…”

Section: Related Workmentioning

confidence: 99%

Deterministic parallel fixpoint computation

Kim

Venet

Thakur

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

interpretation is a general framework for expressing static program analyses. It reduces the problem of extracting properties of a program to computing an approximation of the least fixpoint of a system of equations. The de facto approach for computing this approximation uses a sequential algorithm based on weak topological order (WTO). This paper presents a deterministic parallel algorithm for fixpoint computation by introducing the notion of weak partial order (WPO). We present an algorithm for constructing a WPO in almost-linear time. Finally, we describe Pikos, our deterministic parallel abstract interpreter, which extends the sequential abstract interpreter IKOS. We evaluate the performance and scalability of Pikos on a suite of 1017 C programs. When using 4 cores, Pikos achieves an average speedup of 2.06x over IKOS, with a maximum speedup of 3.63x. When using 16 cores, Pikos achieves a maximum speedup of 10.97x.Program analysis is a widely adopted approach for automatically extracting properties of the dynamic behavior of programs [Balakrishnan et al. 2010; Ball et al. 2004;Brat and Venet 2005;Delmas and Souyris 2007;Jetley et al. 2008]. Program analyses are used, for instance, for program optimization, bug finding, and program verification. To be effective, a program analysis needs to be efficient, precise, and deterministic (the analysis always computes the same output for the same input program) [Bessey et al. 2010]. This paper aims to improve the efficiency of program analysis without sacrificing precision or determinism.Abstract interpretation [Cousot and Cousot 1977] is a general framework for expressing static program analyses. A typical use of abstract interpretation to determine program invariants involves:C1 An abstract domain A that captures relevant program properties. Abstract domains have been developed to perform, for instance, numerical analysis [Cousot and HalbwachsEach index i ∈ [1, n] corresponds to a control point of the program, the unknowns X i of the system correspond to the invariants to be computed for these control points, and each F i is a monotone operator incorporating the abstract transformers and control flow of the program. C3 Computing an approximation of the least fixpoint of Eq. 1. The exact least solution of the system can be computed using Kleene iteration starting from the least element of A n provided A is Noetherian. However, most interesting abstract domains require the use of widening to ensure termination, which may result in an over-approximation of the invariants of the program. A subsequent narrowing iteration tries to improve the post solution via a downward fixpoint iteration. In practice, abstract interpreters compute an approximation of the least fixpoint. In this paper, we use "fixpoint" to refer to such an approximation of the least fixpoint.The iteration strategy specifies the order in which the equations in Eq. 1 are applied during fixpoint computation and where widening is performed. For a given abstraction, the efficiency, precision, and determinism o...

show abstract

Parallel Pointer Analysis with CFL-Reachability

Cited by 26 publications

References 24 publications

The fine-grained and parallel complexity of andersen’s pointer analysis

The fine-grained and parallel complexity of andersen’s pointer analysis

An Efficient GPU Implementation of Inclusion-Based Pointer Analysis

Deterministic parallel fixpoint computation

Contact Info

Product

Resources

About