Parallel flow-sensitive pointer analysis by graph-rewriting

Nagaraj, Vaivaswatha; Govindarajan, R.

doi:10.1109/pact.2013.6618793

Cited by 10 publications

(7 citation statements)

References 0 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Value-Flow Type Def-Use Info of a memory SSA variable Value-flows The SVFG obtained this way may contain spurious defuse chains, such as 5 a Ý Ñ 9 in Figure 4, as Andersen's flow-and context-insensitive pointer analysis is fast but imprecise. However, this representation allows imprecise points-to information to be refined by performing sparse whole-program flow-sensitive pointer analysis as in prior work [20,32,49,61]. In this paper, we introduce a demanddriven flow-and context-sensitive pointer analysis with strong updates that can answer points-to queries efficiently and precisely on-demand, by removing spurious def-use chains in the SVFG iteratively.…”

Section: (B) Gives the Rules For Connecting Value-flows Between Two Instructions Based On The Defs And Uses Computed In Table 2(a) For Inmentioning

confidence: 99%

Value-Flow-Based Demand-Driven Pointer Analysis for C and C++

Sui

Xue

2020

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

We present SUPA, a value-flow-based demand-driven flow-and context-sensitive pointer analysis with strong updates for C and C++ programs. SUPA enables computing points-to information via value-flow refinement, in environments with small time and memory budgets. We formulate SUPA by solving a graph-reachability problem on an inter-procedural value-flow graph representing a program's def-use chains, which are pre-computed efficiently but over-approximately. To answer a client query (a request for a variable's points-to set), SUPA reasons about the flow of values along the pre-computed def-use chains sparsely (rather than across all program points), by performing only the work necessary for the query (rather than analyzing the whole program). In particular, strong updates are performed to filter out spurious def-use chains through value-flow refinement as long as the total budget is not exhausted. We have implemented SUPA on top of LLVM (4.0.0) together with a comprehensive micro-benchmark suite after a years-long effort (consisting of around 400 test cases, including hand-written ones and the ones extracted from real programs). We have evaluated SUPA by choosing uninitialized pointer detection and C++ virtual table resolution as two major clients, using 24 real-world programs including 18 open-source C programs and 6 large CPU2000/2006 C++ benchmarks. For uninitialized pointer client, SUPA achieves improved precision as the analysis budget increases, with its flow-sensitive (context-insensitive) analysis reaching 97.4% of that achieved by whole-program Sparse Flow-Sensitive analysis (SFS) by consuming about 0.18 seconds and 65KB of memory per query, on average (with a budget of at most 10000 value-flow edges per query). With context-sensitivity also considered, SUPA becomes more precise for some programs but also incurs more analysis times. To further demonstrate the effectiveness of SUPA, we have also evaluated SUPA in resolving C++ virtual tables by querying the function pointers at every virtual callsite. Compared to analysis without strong updates for heap objects, SUPA's demand-driven context-sensitive strong update analysis reduces 7.35% spurious virtual table targets with only 0.4 secs per query, on average.

show abstract

Section: (B) Gives the Rules For Connecting Value-flows Between Two Instructions Based On The Defs And Uses Computed In Table 2(a) For Inmentioning

confidence: 99%

Value-Flow-Based Demand-Driven Pointer Analysis for C and C++

Sui

Xue

2020

IIEEE Trans. Software Eng.

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: 99%

An Efficient GPU Implementation of Inclusion-Based Pointer Analysis

Su¹,

Ye²,

Xue³

et al. 2016

IEEE Trans. Parallel Distrib. Syst.

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

“…In recent years, there have been a number of attempts on parallelising pointer analysis algorithms for analysing C or Java programs on multi-core CPUs and/or GPUs [3], [7], [8], [9], [10], [14], [20]. As compared in Table II, all these parallel solutions are different forms of Andersen's pointer analysis [2] with varying precision considerations in terms of context-, flow-and field-sensitivity.…”

Section: B Parallel Pointer Analysismentioning

confidence: 99%

“…Their analysis is fieldinsensitive but flow-sensitive (only partially since it does not perform strong updates). Recently, both field-and flowsensitivity (with strong updates for singleton objects) are handled for C programs on multi-core CPUs [9] and GPUs [10]. The speedups are up to 2.6X on eight CPU cores and 7.8X (with precision loss) on a Tesla C2070 GPU, respectively.…”

Section: B Parallel Pointer Analysismentioning

confidence: 99%

“…There have been a few parallel implementations of Andersen's pointer analysis on multi-core CPUs [3], [8], [9], [14], GPUs [7], [10], and heterogeneous CPU-GPU systems [20], as compared in detail in Table II. As Andersen's analysis is a whole-program pointer analysis, these earlier solutions cannot be applied to parallelise demand-driven pointer analysis.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Parallel Pointer Analysis with CFL-Reachability

Xue

2014

2014 43rd International Conference on Parallel Processing

View full text Add to dashboard Cite

Abstract-This paper presents the first parallel implementation of pointer analysis with Context-Free Language (CFL) reachability, an important foundation for supporting demand queries in compiler optimisation and software engineering. Formulated as a graph traversal problem (often with context-and field-sensitivity for desired precision) and driven by queries (issued often in batch mode), this analysis is non-trivial to parallelise.We introduce a parallel solution to the CFL-reachability-based pointer analysis, with context-and field-sensitivity. We exploit its inherent parallelism by avoiding redundant graph traversals with two novel techniques, data sharing and query scheduling. With data sharing, paths discovered in answering a query are recorded as shortcuts so that subsequent queries will take the shortcuts instead of re-traversing its associated paths. With query scheduling, queries are prioritised according to their statically estimated dependences so that more redundant traversals can be further avoided. Evaluated using a set of 20 Java programs, our parallel implementation of CFL-reachability-based pointer analysis achieves an average speedup of 16.2X over a state-ofthe-art sequential implementation on 16 CPU cores.

show abstract

Parallel flow-sensitive pointer analysis by graph-rewriting

Cited by 10 publications

References 0 publications

Value-Flow-Based Demand-Driven Pointer Analysis for C and C++

Value-Flow-Based Demand-Driven Pointer Analysis for C and C++

An Efficient GPU Implementation of Inclusion-Based Pointer Analysis

Parallel Pointer Analysis with CFL-Reachability

Contact Info

Product

Resources

About