ThinLTO: Scalable and incremental LTO

Johnson, T.L.; Amini, Mehdi; Li, Xinliang David

doi:10.1109/cgo.2017.7863733

Cited by 27 publications

(10 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Others [Porat et al 1996;Zendra et al 1997] do eliminate virtual tables entirely, however they require whole program visibility which prevents separate compilation and is not always feasible in practice. A number of recent works aim at making whole-program optimization and link-time optimization more effective [Doeraene and Schlatter 2016;Johnson et al 2017a;Sathyanathan et al 2017] or at improving call graph analyses [Johnson et al 2017b;Petrashko et al 2016;Tan et al 2017;Tip and Palsberg 2000] which can increase the scope and precision of devirtualization optimizations.…”

Section: Implementations Of Dynamic Dispatchmentioning

confidence: 99%

SAVI objects: sharing and virtuality incorporated

Hajj

Jablin

Milojičić

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Direct sharing and storing of memory objects allows high-performance and low-overhead collaboration between parallel processes or application workflows with loosely coupled programs. However, sharing of objects is hindered by the inability to use subtype polymorphism which is common in object-oriented programming languages. That is because implementations of subtype polymorphism in modern compilers rely on using virtual tables stored at process-specific locations, which makes objects unusable in processes other than the creating process.In this paper, we present SAVI Objects, objects with Sharing and Virtuality Incorporated. SAVI Objects support subtype polymorphism but can still be shared across processes and stored in persistent data structures. We propose two different techniques to implement SAVI Objects and evaluate the tradeoffs between them. The first technique is virtual table duplication which adheres to the virtual-table-based implementation of subtype polymorphism, but duplicates virtual tables for shared objects to fixed memory addresses associated with each shared memory region. The second technique is hashing-based dynamic dispatch which re-implements subtype polymorphism using hashing-based look-ups to a global virtual table.Our results show that SAVI Objects enable direct sharing and storing of memory objects that use subtype polymorphism by adding modest overhead costs to object construction and dynamic dispatch time. SAVI Objects thus enable faster inter-process communication, improving the overall performance of production applications that share polymorphic objects.

show abstract

Section: Implementations Of Dynamic Dispatchmentioning

confidence: 99%

SAVI objects: sharing and virtuality incorporated

Hajj

Jablin

Milojičić

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…Linktime optimization [16] can offer better visibility, however, the analysis is still conservative and may err on the side of being less exhaustive to reduce prohibitive analysis cost. Wholeprogram link-time optimizations [17], [18] have provided less than 5% average speedup, although a lot more headroom exists as we show in our work. Thus, despite their best efforts, compilers often fall short of eliminating runtime inefficiencies.…”

Section: Introductionmentioning

confidence: 70%

Redundant Loads: A Software Inefficiency Indicator

Wen

Yang

et al. 2019

2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE)

View full text Add to dashboard Cite

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; }

show abstract

“…Compilation in full LTO mode is already memory hungry. Just keeping the whole program in memory can be a significant problem for large programs [10]. Maintaining additional information for every function and basic block could easily tip the compiler over the edge.…”

Section: Memory Usagementioning

confidence: 99%

“…Existing techniques range from simple passes merging identical functions at the compiler intermediate representation (IR) [2,15] or the binary level [1, 13,25] up to approaches that identify and merge similar subsequences in otherwise dissimilar functions [9,20,21]. As already noted by Chabbi et al [4], these techniques have either limited benefit on code reduction or unacceptable compilation overheads for production, especially considering builds using link-time optimizations (LTO) where inter-procedural optimizations have greater opportunities but at a greater cost [10].…”

Section: Introductionmentioning

confidence: 99%

HyFM: function merging for free

Rocha

Petoumenos

Wang

et al. 2021

Proceedings of the 22nd ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems

View full text Add to dashboard Cite

Function merging is an important optimization for reducing code size. The existing state-of-the-art relies on a wellknown sequence alignment algorithm to identify duplicate code across whole functions. However, this algorithm is quadratic in time and space on the number of instructions. This leads to very high time overheads and prohibitive levels of memory usage even for medium-sized benchmarks. For larger programs, it becomes impractical. This is made worse by an overly eager merging approach. All selected pairs of functions will be merged. Only then will this approach estimate the potential benefit from merging and decide whether to replace the original functions with the merged one. Given that most pairs are unprofitable, a significant amount of time is wasted producing merged functions that are simply thrown away.In this paper, we propose HyFM, a novel function merging technique that delivers similar levels of code size reduction for significantly lower time overhead and memory usage. Our alignment strategy works at the block level. Since basic blocks are usually much shorter than functions, even a quadratic alignment is acceptable. However, we also propose a linear algorithm for aligning blocks at a much lower cost. We extend this strategy with a multi-tier profitability analysis that bails out early from unprofitable merging attempts. By aligning individual pairs of blocks, we are able to decide their alignment's profitability before actually generating code.Experimental results on SPEC 2006 and 2017 show that HyFM needs orders of magnitude less memory, using up to 48 MB or 5.6 MB, depending on the variant used, while

show abstract

ThinLTO: Scalable and incremental LTO

Cited by 27 publications

References 9 publications

SAVI objects: sharing and virtuality incorporated

SAVI objects: sharing and virtuality incorporated

Redundant Loads: A Software Inefficiency Indicator

HyFM: function merging for free

Contact Info

Product

Resources

About