Redundant Loads: A Software Inefficiency Indicator

Abstract

1 while (t < threshold) { 2 t = 0; 3 for(i = 0; i < N; i++) 4 t += A[i] + B[i] * delta; 5 delta -= 0.1 * t; 6 } 1 for (i = 0; i < N; i++) 2 a += A[i]; b += B[i]; 3 while (t < threshold) { 4 t = a + b * delta; 5 delta -= 0.1 * t; 6 } Listing 1: An example code (on the left) with temporal inefficiencies that cannot be identified by existing fine-grained profilers. Because arrays A and B are immutable in the loop nest, computing on these loop invariants introduces many redundancies. One can hoist the redundant computation outside of the loop (on the right) for optimization. 1 int A[N] = {1, 1, 1, 15}; 2 for(i = 0; i < N; i++) 3 { 4 t += func(A[i]); 5 } 1 int A[N] = {1, 1, 1, 15}; 2 a = func(A[0]); 3 for(i = 0; i < N; i++) { 4 if (A[i] != A[i-1]) 5 a = func(A[i]); 6 t += a; }

ValueExpert: exploring value patterns in GPU-accelerated applications

“…However, these instrumentation engines do not directly identify value-related inefficiencies. State-ofthe-art profilers for identifying value-related inefficiencies include RedSpy [51], LoadSpy [47], and Witch [52]; however, these tools work on CPUs only. In this section, we only discuss most related approaches to ValueExpert.…”

BinGo: Pinpointing Concurrency Bugs in Go via Binary Analysis

“…Binary engines, such as Pin [35], DynamoRIO [5], Dyninst [6], and Valgrind [19], can instrument any instruction of interest for performance characterization and bug detection. The performance characterization tools include redundancy detection [24,39,41,42], data locality measurement [33,43], cache simulation [23]. The bug detection includes aforementioned concurrency bug analysis, taint analysis [21], reverse engineering [31], and execution replay [36].…”

Toward efficient interactions between Python and native libraries

“…While there are many native profiling tools [2,15,54], from which the most related to Python that can identify performance inefficiencies are Toddler [44] that identifies redundant memory loads across loop iterations, and LDoctor [57] that reduces Toddler's overhead by applying dynamic sampling and static analysis. DeadSpy [9], RedSpy [71], and Load-Spy [62] analyze dynamic instructions in the entire program execution to detect useless computations or data movements. Unfortunately, all of them use heavyweight binary instrumentation, which results in high measurement overhead, and they do not work directly on Python programs.…”

“…Python profiles [19,22,24,49,52,55,66,67,75] cannot step in native code so they do not know execution details. Native profiling tools [2,9,15,44,54,62,71,72] can identify hotspots, which sometimes offer leads to problematic code blocks. But because these tools do not have knowledge about Python code's semantic, they cannot render detailed root cause and thus often make debugging remarkably challenging.…”