Finding low-utility data structures

Abstract

Many opportunities for easy, big-win, program optimizations are missed by compilers. This is especially true in highly layered Java applications. Often at the heart of these missed optimization opportunities lie computations that, with great expense, produce data values that have little impact on the program's final output. Constructing a new date formatter to format every date, or populating a large set full of expensively constructed structures only to check its size: these involve costs that are out of line with the benefits gained. This disparity between the formation costs and accrued benefits of data structures is at the heart of much runtime bloat.We introduce a run-time analysis to discover these low-utility data structures. The analysis employs dynamic thin slicing, which naturally associates costs with value flows rather than raw data flows. It constructs a model of the incremental, hop-to-hop, costs and benefits of each data structure. The analysis then identifies suspicious structures based on imbalances of its incremental costs and benefits. To decrease the memory requirements of slicing, we introduce abstract dynamic thin slicing, which performs thin slicing over bounded abstract domains. We have modified the IBM J9 commercial JVM to implement this approach.We demonstrate two client analyses: one that finds objects that are expensive to construct but are not necessary for the forward execution, and second that pinpoints ultimately-dead values. We have successfully applied them to large-scale and long-running Java applications. We show that these analyses are effective at detecting operations that have unbalanced costs and benefits.

Statistical debugging for real-world performance problems

“…Each of these tools detects one specific type of performance bugs, such as inefficient nested loops [37], under-utilized data structures [46], and temporary object bloat [12,44,45], through static or dynamic program analysis. They are not designed to cover a wide variety of performance bugs.…”

“…Xu et al [46] targets low-utility data structures with unbalanced costs and benefits. Jin et al [21] employ rule-based methods to detect performance bugs that violate efficiency rules that have been violated before.…”

Statistical debugging for real-world performance problems

“…Each of these tools detects one specific type of performance bugs, such as inefficient nested loops [30], under-utilized data structures [38], and temporary object bloat [11,36,37], through static or dynamic program analysis. They are not designed to cover a wide variety of performance bugs.…”

“…Xu et al [38] targets low-utility data structures with unbalanced costs and benefits. Jin et al [18] employ rule-based methods to detect performance bugs that violate efficiency rules that have been violated before.…”

Data-driven synthesis for object-oriented frameworks

“…The synthesis algorithm relies on a dynamic form of thin slicing, an approach to slicing pioneered by Sridharan et al that has been shown to be very effective when computing slices for the purpose of program understanding [15,19]. The basic observation behind thin slicing is that traditional slices contain too much information; for example, a slice for an operation that retrieves an element from a data-structure will contain not only the event that inserted the element into the data-structure but also many other events that modified the data-structure, including many that added and removed other unrelated elements.…”