Scalable Flow-Sensitive Pointer Analysis for Java with Strong Updates

De, Arnab; D’Souza, Deepak

doi:10.1007/978-3-642-31057-7_29

Cited by 28 publications

(31 citation statements)

References 38 publications

(47 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…• Hybrid model. Chakraborty [14] describes a hybrid heap model which represents heap structures using a combination of store based and storeless models [16,25,50,72]. Heap memory of Figure 3b is represented using the hybrid model in Figure 7.…”

Section: Heap Summarization Techniquesmentioning

confidence: 99%

“…De and D'Souza [16] highlight an imprecision in saving pointer information as graphs. We illustrate this imprecision using Figure 19a for statements 9, 10, and 11 of our running program in Figure 8a.…”

Section: K-limiting Summarizationmentioning

confidence: 99%

“…De and D'Souza [16] believe that this imprecision is caused by storing points-to information as graphs. Therefore, instead of using graphs, they use access paths.…”

Section: K-limiting Summarizationmentioning

confidence: 99%

See 2 more Smart Citations

Heap Abstractions for Static Analysis

Kanvar

Khedker

2016

ACM Comput. Surv.

View full text Add to dashboard Cite

Heap data is potentially unbounded and seemingly arbitrary. As a consequence, unlike stack and static memory, heap memory cannot be abstracted directly in terms of a fixed set of source variable names appearing in the program being analysed. This makes it an interesting topic of study and there is an abundance of literature employing heap abstractions. Although most studies have addressed similar concerns, their formulations and formalisms often seem dissimilar and some times even unrelated. Thus, the insights gained in one description of heap abstraction may not directly carry over to some other description. This survey is a result of our quest for a unifying theme in the existing descriptions of heap abstractions. In particular, our interest lies in the abstractions and not in the algorithms that construct them.In our search of a unified theme, we view a heap abstraction as consisting of two features: a heap model to represent the heap memory and a summarization technique for bounding the heap representation. We classify the models as storeless, store based, and hybrid. We describe various summarization techniques based on k-limiting, allocation sites, patterns, variables, other generic instrumentation predicates, and higher-order logics. This approach allows us to compare the insights of a large number of seemingly dissimilar heap abstractions and also paves way for creating new abstractions by mix-and-match of models and summarization techniques. Heap Analysis: MotivationHeap data is potentially unbounded and seemingly arbitrary. Although there is a plethora of literature on heap, the formulations and formalisms often seem dissimilar. This survey is a result of our quest for a unifying theme in the existing descriptions of heap. Why Heap?Unlike stack or static memory, heap memory allows on-demand memory allocation based on the statements in a program (and not just variable declarations). Thus it facilitates creation of flexible data structures which can outlive the procedures that create them and whose sizes can change during execution. With processors becoming faster and memories becoming larger as well as faster, the ability of creating large and flexible data structures increases. Thus the role of heap memory in user programs as well as design and implementation of programming languages becomes more significant. Why Heap Analysis? Why Heap Analysis?The increasing importance of the role of heap memory naturally leads to a myriad requirements of its analysis. Although heap data has been subjected to static as well as dynamic analyses, in this paper, we restrict ourselves to static analysis.Heap analysis, at a generic level, provides useful information about heap data, i.e. heap pointers or references. Additionally, it helps in discovering control flow through dynamic dispatch resolution. Specific applications that can benefit from heap analysis include program understanding, program refactoring, verification, debugging, enhancing security, improving performance, compile time garbage collection, inst...

show abstract

Section: Heap Summarization Techniquesmentioning

confidence: 99%

Section: K-limiting Summarizationmentioning

confidence: 99%

See 1 more Smart Citation

Heap Abstractions for Static Analysis

Kanvar

Khedker

2016

ACM Comput. Surv.

View full text Add to dashboard Cite

show abstract

“…For points-to multibloom, the rows correspond to pointers and the columns indicate address-taken variables. In our implementation, we treat pointers and objects in a uniform fashion, unlike in strongly typed languages such as Java wherein pointers (called references) and objects are clearly demarcated [De and De'Souza 2012]. Thus, in Java, an object cannot act as a reference.…”

Section: Using Multibloomsmentioning

confidence: 99%

Time- and space-efficient flow-sensitive points-to analysis

Nasre

2013

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Compilation of real-world programs often requires hours. The term nightly build known to industrial researchers is an artifact of long compilation times. Our goal is to reduce the absolute analysis times for large C codes (of the order of millions of lines). Pointer analysis is one of the key analyses performed during compilation. Its scalability is paramount to achieve the efficiency of the overall compilation process and its precision directly affects that of the client analyses. In this work, we design a time-and space-efficient flow-sensitive pointer analysis and parallelize it on graphics processing units. Our analysis proposes to use an extended bloom filter, called multibloom, to store points-to information in an approximate manner and develops an analysis in terms of the operations over the multibloom. Since bloom filter is a probabilistic data structure, we develop ways to gain back the analysis precision. We achieve effective parallelization by achieving memory coalescing, reducing thread divergence, and improving load balance across GPU warps. Compared to a state-of-the-art sequential solution, our parallel version achieves a 7.8× speedup with less than 5% precision loss on a suite of six large programs. Using two client transformations, we show that this loss in precision only minimally affects a client's precision. ACM Reference Format:Nasre, R. 2013. Time-and space-efficient flow-sensitive points-to analysis. ACM Trans. analysis directly affects the client analyses and transformations [Hind and Pioli 2000].However, industry-strength compilers need to use flow-insensitive pointer analysis because of the high analysis time and memory cost of a flow-sensitive analysis.The benefit of a flow-sensitive pointer analysis over that of a flow-insensitive analysis has not been clear [Hind and Pioli 1998]. However, it has been shown that a precise pointer analysis is helpful to several clients, such as typestate verification [Fink et al. 2008], security analysis [Chang et al. 2008], bug detection [Guyer and Lin 2005], and the analysis of multithreaded programs [Salcianu and Rinard 2001]. As a result, there is a renewed interest in the area of flow-sensitive pointer analysis, and the scalability of such analyses has been greatly improved [Hardekopf and Lin 2011; Li et al. 2011; Yu et al. 2010; Lhoták and Chung 2011; Hardekopf and Lin 2009; Kahlon 2008]. However, despite these efforts, industrial response to the adoption of these analyses has been lukewarm. For instance, widely used compilers like GCC [GCC 2013] and LLVM [Lattner and Adve 2004] rely on flow-insensitive pointer analysis, despite the known advantages of a flow-sensitive analysis. One of the main reasons behind this pessimistic reaction is high absolute running times of several analyses over large-sized codes. As an example, a state-of-the-art flow-sensitive pointer analysis [Hardekopf and Lin 2011] over gs, an open-source postscript viewer, totaling 0.4 million lines of C code, requires more than half an hour to complete! Considering that pointer a...

show abstract

“…) Modeling the flow of data through the heap requires handling pointers and aliasing. We consider three different choices of heap abstraction: using summary objects [25,27], which are weakly updated, to summarize multiple heap locations; access paths [21,52], which are strongly updated ; and a combination of the two.…”

Section: Introductionmentioning

confidence: 99%

Evaluating Design Tradeoffs in Numeric Static Analysis for Java

Wei

Mardziel

Ruef

et al. 2018

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. Numeric static analysis for Java has a broad range of potentially useful applications, including array bounds checking and resource usage estimation. However, designing a scalable numeric static analysis for real-world Java programs presents a multitude of design choices, each of which may interact with others. For example, an analysis could handle method calls via either a top-down or bottom-up interprocedural analysis. Moreover, this choice could interact with how we choose to represent aliasing in the heap and/or whether we use a relational numeric domain, e.g., convex polyhedra. In this paper, we present a family of abstract interpretation-based numeric static analyses for Java and systematically evaluate the impact of 162 analysis configurations on the DaCapo benchmark suite. Our experiment considered the precision and performance of the analyses for discharging array bounds checks. We found that top-down analysis is generally a better choice than bottom-up analysis, and that using access paths to describe heap objects is better than using summary objects corresponding to pointsto analysis locations. Moreover, these two choices are the most significant, while choices about the numeric domain, representation of abstract objects, and context-sensitivity make much less difference to the precision/performance tradeoff.

show abstract

Scalable Flow-Sensitive Pointer Analysis for Java with Strong Updates

Cited by 28 publications

References 38 publications

Heap Abstractions for Static Analysis

Heap Abstractions for Static Analysis

Time- and space-efficient flow-sensitive points-to analysis

Evaluating Design Tradeoffs in Numeric Static Analysis for Java

Contact Info

Product

Resources

About