Reuse, Recycle to De-bloat Software

Bhattacharya, Suparna; Nanda, Mangala Gowri; Gopinath, K.; Gupta, Manish

doi:10.1007/978-3-642-22655-7_19

Cited by 24 publications

(32 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…3 We configured the JVM with the following settings additional to the -server flag: with -Xms4G -Xmx4G we set the heap to a fixed size of 4GB and prohibit resizing; -XX:+DisableExplicitGC deactivates manual invocation of the GC; -XX:+UseParallelOldGC uses a parallel collector for new and old generations.…”

Section: Setup Of Jvm Parametersmentioning

confidence: 99%

Performance Modeling of Maximal Sharing

Steindorfer

Vinju

2016

Proceedings of the 7th ACM/SPEC on International Conference on Performance Engineering

View full text Add to dashboard Cite

It is noticeably hard to predict the effect of optimization strategies in Java without implementing them. "Maximal sharing" (a.k.a. "hash-consing") is one of these strategies that may have great benefit in terms of time and space, or may have detrimental overhead. It all depends on the redundancy of data and the use of equality.We used a combination of new techniques to predict the impact of maximal sharing on existing code: Object Redundancy Profiling (ORP) to model the effect on memory when sharing all immutable objects, and Equals-Call Profiling (ECP) to reason about how removing redundancy impacts runtime performance. With comparatively low effort, using the MAximal SHaring Oracle (MASHO), a prototype profiler based on ORP and ECP, we can uncover optimization opportunities that otherwise would remain hidden. This is an experience report on applying MASHO to real and complex case: we conclude that ORP and ECP combined can accurately predict gains and losses of maximal sharing, and also that (by isolating variables) a cheap predictive model can sometimes provide more accurate information than an expensive experiment can.

show abstract

Section: Setup Of Jvm Parametersmentioning

confidence: 99%

Performance Modeling of Maximal Sharing

Steindorfer

Vinju

2016

Proceedings of the 7th ACM/SPEC on International Conference on Performance Engineering

View full text Add to dashboard Cite

show abstract

“…Software bloat analysis [19,4,20,1,21,22,3,2,23,24] attempts to identify and remove performance problems due to run-time inefficiencies in the code execution and the use of memory. Mitchell et al [5] propose a manual approach that detects bloat by structuring behavior according to the flow of information, and their later work [4] introduces a way to find data structures that consume excessive amounts of memory.…”

Section: Related Workmentioning

confidence: 99%

CoCo: Sound and Adaptive Replacement of Java Collections

2013

ECOOP 2013 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. Inefficient use of Java containers is an important source of run-time inefficiencies in large applications. This paper presents an application-level dynamic optimization technique called CoCo, that exploits algorithmic advantages of Java collections to improve performance. CoCo dynamically identifies optimal Java collection objects and safely performs run-time collection replacement, both using pure Java code. At the heart of this technique is a framework that abstracts container elements to achieve efficiency and that concretizes abstractions to achieve soundness. We have implemented part of the Java collection framework as instances of this framework, and developed a static CoCo compiler to generate Java code that performs optimizations. This work is the first step towards achieving the ultimate goal of automatically optimizing away semantic inefficiencies.

show abstract

“…Otherwise, its value may be updated by each iteration and any data structure that is dependent on this value is not hoistable. For example, in Figure 3(b), o 21 .value depends on variable j, whose ICA is 0. Because j is in a dependence cycle, o 21 .value may have iteration-specific values, and thus, any data structure that contains o 21 is not hoistable (e.g., structures (a.2) and (a.3) in Figure 3(a)).…”

Section: Overviewmentioning

confidence: 99%

“…For example, in Figure 3(b), o 21 .value depends on variable j, whose ICA is 0. Because j is in a dependence cycle, o 21 .value may have iteration-specific values, and thus, any data structure that contains o 21 is not hoistable (e.g., structures (a.2) and (a.3) in Figure 3(a)). Note that field o 3 .elm is loopinvariant: while it depends on field o 15 .index, which is involved in a cycle, o 15 's ICA is 1.…”

Section: Overviewmentioning

confidence: 99%

“…As discussed earlier, it may not be feasible to find such optimizable data structures using a dynamic analysis, which requires to profile all values generated during an execution, a task prohibitively expensive for real-world programs. Bhattacharya et al propose an escape-analysis-based static technique [21] that can find reusable collections in a loop. Our analysis is more powerful: we can find general data structures that have disjoint instances as well as the same shapes and data content.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Static Detection of Loop-Invariant Data Structures

Yan

Rountev

2012

ECOOP 2012 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. As a culture, object-orientation encourages programmers to create objects, both short-and long-lived, without concern for cost. Excessive object creation and initialization can cause severe runtime bloat, which degrades significantly application performance and scalability. A frequently-occurring coding pattern that may lead to large volumes of (temporary) objects is the creation of objects that, while allocated per loop iteration, contain values independent of specific iterations. Finding these objects and moving them out of loops requires sophisticated interprocedural analysis, a task that is difficult for traditional dataflow analyses such as loop-invariant code motion to accomplish.Our work targets data structures that are loop-invariant, and presents a static type and effect system to detect loop-invariant data structures. For each loop, our analysis inspects each logical data structure in order to find those that have disjoint instances per loop iteration and contain loop-invariant data. Instead of automatically hoisting them to improve performance (which is over-conservative), we report hoistability measurements for each disjoint loop data structure detected by our analysis. Eventually these data structures are ranked based on these measurements and are presented to the user to help manual tuning. We have performed a variety of studies on a set of 19 moderate/large-sized Java benchmarks. With the help of hoistability measurements, we found optimization opportunities in most of the programs that we inspected and achieved significant performance improvements in some of them (e.g., 82.1% running time reduction).

show abstract

Reuse, Recycle to De-bloat Software

Cited by 24 publications

References 22 publications

Performance Modeling of Maximal Sharing

Performance Modeling of Maximal Sharing

CoCo: Sound and Adaptive Replacement of Java Collections

Static Detection of Loop-Invariant Data Structures

Contact Info

Product

Resources

About