Region-Based Selective Flow-Sensitive Pointer Analysis

2015 44th International Conference on Parallel Processing

et al. 2015

Self Cite

The C programming language continues to play an essential role in the development of system software. May-Happen-in-Parallel (MHP) analysis is the basis of many other analyses and optimisations for concurrent programs. Existing MHP analyses that work well for programming languages such as X10 are often not effective for C (with Pthreads). This paper presents a new MHP algorithm for C that operates at the granularity of code regions rather than individual statements in a program. A flowsensitive Happens-Before (HB) analysis is performed to account for fork-join semantics of Pthreads on an interprocedural thread-sensitive control flow graph representation of a program, enabling the HB relations among its statements to be discovered. All the statements that share the same HB properties are then grouped into one region. As a result, computing the MHP information for all pairs of statements in a program is reduced to one of inferring the HB relations from among its regions.We have implemented our algorithm in LLVM-3.5.0 and evaluated it using 14 programs from the SPLASH2 and PARSEC benchmark suites. Our preliminary results show that our approach is more precise than two existing MHP analyses yet computationally comparable with the fastest MHP analysis.

“…All interprocedural edges represent the calling relations across the procedures. Indirect calls can be found using Andersen's pointer analysis [11], [12], [13].…”

Section: B Thread-sensitive Control Flow Graphmentioning

confidence: 99%

“…Following [9], [15], we presently conduct a may-alias analysis [11], [12], [13] to approximate the set of abstract threads joined at a join site. This can be unsound as a may-analysis is conservative.…”

Section: Modeling Thread Joinsmentioning

confidence: 99%

Region-Based May-Happen-in-Parallel Analysis for C Programs

Peng

2015 44th International Conference on Parallel Processing

et al. 2015

Self Cite

“…Compared to pointer analysis for sequential programs [17,45,43,44,51,19], flow-sensitive analysis for multithreaded programs is relatively unexplored. Earlier, Rugina and Rinard [35] introduced a pointer analysis for Clik programs with structured parallelism.…”

Section: Pointer Analysis For Multithreaded Programsmentioning

confidence: 99%

Accelerating Dynamic Data Race Detection Using Static Thread Interference Analysis

Peng

Proceedings of the 7th International Workshop on Programming Models and Applications for Multicores and Manycores

2016

Self Cite

Precise dynamic race detectors report an error if and only if more than one thread concurrently exhibits conflict on a memory access. They insert instrumentations at compiletime to perform runtime checks on all memory accesses to ensure that all races are captured and no spurious warnings are generated. However, a dynamic race check for a particular memory access statement is guaranteed to be redundant if the statement can be statically identified as thread interference-free. Despite significant recent advances in dynamic detection techniques, the redundant check remains a critical factor that leads to prohibitive overhead of dynamic race detection for multithreaded programs.In this paper, we present a new framework that eliminates redundant race check and boosts the dynamic race detection by performing static optimizations on top of a series of thread interference analysis phases. Our framework is implemented on top of LLVM 3.5.0 and evaluated with an industry dynamic race detector TSAN which is available as a part of LLVM tool chain. 11 benchmarks from SPLASH2 are used to evaluate the effectiveness of our approach in accelerating TSAN by eliminating redundant interference-free checks. The experimental result demonstrates our new approach achieves from 1.4x to 4.0x (2.4x on average) speedup over original TSAN under 4 threads setting, and achieves from 1.3x to 4.6x (2.6x on average) speedup under 16 threads setting.

“…Thus, the data-flow facts that reach a confluence point along different paths are merged. Improving on this, sparse flow-sensitive pointer analysis (SFS) [20,30,33,61,62] boosts the performance of FS in analyzing large C programs while maintaining the same strong updates done by FS. The basic idea is to first conduct a pre-analysis on the program to over-approximate its defuse chains and then perform FS by propagating the dataflow facts, i.e., points-to information sparsely along only the pre-computed def-use chains (aka value-flows) instead of all program points in the program's control-flow graph (CFG).…”

Section: Introductionmentioning

confidence: 99%

“…Most of the existing demand-driven analyses for C [21,63,66] and Java [31,39,41,43,57] are flow-insensitive and thus cannot perform strong updates to produce the precision needed by some clients. Elsewhere, advances in wholeprogram flow-sensitive analysis for C have exploited some form of sparsity to improve performance [20,30,33,61,62]. However, how to replicate this success for demand-driven flow-sensitive analysis is unclear.…”

Section: Introductionmentioning

confidence: 99%

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

IIEEE Trans. Software Eng.

Xue

2020

Self 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.