Pinpointing performance inefficiencies in Java

Abstract

Many performance inefficiencies such as inappropriate choice of algorithms or data structures, developers' inattention to performance, and missed compiler optimizations show up as wasteful memory operations. Wasteful memory operations are those that produce/consume data to/from memory that may have been avoided. We present, JXPerf, a lightweight performance analysis tool for pinpointing wasteful memory operations in Java programs. Traditional byte-code instrumentation for such analysis (1) introduces prohibitive overheads and (2) misses inefficiencies in machine code generation. JXPerf overcomes both of these problems. JXPerf uses hardware performance monitoring units to sample memory locations accessed by a program and uses hardware debug registers to monitor subsequent accesses to the same memory. The result is a lightweight measurement at machine-code level with attribution of inefficiencies to their provenance -machine and source code within full calling contexts. JXPerf introduces only 7% runtime overhead and 7% memory overhead making it useful in production. Guided by JXPerf, we optimize several Java applications by improving code generation and choosing superior data structures and algorithms, which yield significant speedups. CCS CONCEPTS• General and reference → Metrics; Performance; • Software and its engineering → Software maintenance tools. 142 for ( int bit = 0, dual = 1; bit < logn ; bit ++ , dual *= 2) { 143 ... 144 for ( int a = 1; a < dual ; a ++) { 145 ... 146 for ( int b = 0; b < n; b += 2* dual ) { 147 int i = 2* b ; 148 int j = 2*( b + dual ); 149 double z1_real = data [j ]; 150 double z1_imag = data [j +1]; 151 double wd_real = w_real * z1_real -w_imag * z1_imag ; 152 double wd_imag = w_real * z1_imag + w_imag * z1_real ; 153 ▶ data [j] = data [i] -wd_real ; 154 data [j +1] = data [i +1] -wd_imag ; 155 ▶ data [i] += wd_real ; 156 data [i +1] += wd_imag ; 157 }}} Listing 1: Redundant memory loads in SPECjvm 2008 scimark.fft. data[i]is loaded from memory twice in a single iteration whereas it is unmodified between these two loads.

OJXPerf: Featherlight Object Replica Detection for Java Programs

“…To guarantee optimization correctness, we ensure the optimized codes do not change semantics for any inputs and pass the validation tests. To avoid system noises, we run each application 30 times and use a 95% confidence interval for the geometric mean speedup to report the performance improvement, according to a prior approach [51].…”

“…As line 94 in Listing 1 shows, each time the readNext method is invoked, it creates a copy of input contents (variable "in"), and uses this copy to initialize many objects "bytes" (object replication). None of the existing profilers, such as JXPerf [51] and LDoctor [50], can identify such object replicas since they are designed only to recognize the redundancies happening at the same memory location. Instead, objects bytes are allocated in disjoint memory regions.…”

“…Remix [18] employs PMU to identify inter-thread false sharing on the fly. JXPerf [51] detects redundant memory operations by using PMU to sample memory locations accessed by a program and using debug registers to monitor subsequent accesses to the same location.…”

Toward efficient interactions between Python and native libraries

“…Our crucial observation is that function calls in different threads near the root of a tree usually repeat so unlike solutions appeared in [8,9,61,62,71], which produce a CCT for each thread/process, PieProf constructs a single CCT for the entire program execution. In this way, the same function call appearing in different threads is compressed into one node and space complexity is reduced.…”

“…PieProf works for production Python software packages running in commodity CPU processors without modifying the software stacks. Its backbones algorithmic module is a recently proposed technique based on hardware performance monitoring units (PMUs) and debug registers to efficiently identify redundant memory accesses (hereafter, referred to as CL-algorithm 1 [61,72]). CL-algorithm intelligently chooses a small collection of memory cells and uses hardware to track accesses to these cells at a fine granularity.…”