CoCo: Sound and Adaptive Replacement of Java Collections

Xu, Guoqing

doi:10.1007/978-3-642-39038-8_1

Cited by 49 publications

(31 citation statements)

References 28 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Work such as [33] and Chameleon [23] is more speciically targeted towards collections and provides either online or oline means to optimize them more for operations on collections in general, and thus goes beyond the type specializations demonstrated here. However, such more advanced optimizations and also the notion of just-in-time data structures [8] could be combined with the optimizations presented here.…”

Section: Related Workmentioning

confidence: 99%

Applying Optimizations for Dynamically-typed Languages to Java

Grimmer¹,

Marr

Kahlhofer

et al. 2017

Proceedings of the 14th International Conference on Managed Languages and Runtimes

View full text Add to dashboard Cite

While Java is a statically-typed language, some of its features make it behave like a dynamically-typed language at run time. This includes Java's boxing of primitive values as well as generics, which rely on type erasure. This paper investigates how runtime technology for dynamically-typed languages such as JavaScript and Python can be used for Java bytecode. Using optimistic optimizations, we specialize bytecode instructions that access references in such a way, that they can handle primitive data directly and also specialize data structures in order to avoid boxing for primitive types. Our evaluation shows that these optimizations can be successfully applied to a statically-typed language such as Java and can also improve performance signiicantly. With this approach, we get an eicient implementation of Java's generics, avoid changes to the Java language, and maintain backwards compatibility, allowing existing code to beneit from our optimization transparently.

show abstract

Section: Related Workmentioning

confidence: 99%

Applying Optimizations for Dynamically-typed Languages to Java

Grimmer¹,

Marr

Kahlhofer

et al. 2017

Proceedings of the 14th International Conference on Managed Languages and Runtimes

View full text Add to dashboard Cite

show abstract

“…Bloat detection has also been attempted by developing dynamic techniques to identify reusable data structures [Xu 2012[Xu , 2013b and cacheable data values [Nguyen and Xu 2013]. In addition, Xu proposes an adaptive technique in Xu [2013a] that can automatically switch container implementations online to improve the performance of programs that make intensive use of object-oriented containers.…”

Section: Bloat Detectionmentioning

confidence: 99%

“…For instance, blended escape analysis [Dufour et al 2007[Dufour et al , 2008 is effective at detection of temporary objects while a container profiling technique [Xu and Rountev 2008;Xu 2013a;Shacham et al 2009] works only for container bloat. Our cost-benefit analysis detects operations that have high costs and low benefits.…”

Section: Bloat Detectionmentioning

confidence: 99%

Scalable Runtime Bloat Detection Using Abstract Dynamic Slicing

Mitchell

Arnold

et al. 2014

ACM Trans. Softw. Eng. Methodol.

Self Cite

View full text Add to dashboard Cite

Many large-scale Java applications suffer from runtime bloat. They execute large volumes of methods and create many temporary objects, all to execute relatively simple operations. There are large opportunities for performance optimizations in these applications, but most are being missed by existing optimization and tooling technology. While JIT optimizations struggle for a few percent improvement, performance experts analyze deployed applications and regularly find gains of 2× or more. Finding such big gains is difficult, for both humans and compilers, because of the diffuse nature of runtime bloat. Time is spread thinly across calling contexts, making it difficult to judge how to improve performance. Our experience shows that, in order to identify large performance bottlenecks in a program, it is more important to understand its dynamic dataflow than traditional performance metrics, such as running time.This article presents a general framework for designing and implementing scalable analysis algorithms to find causes of bloat in Java programs. At the heart of this framework is a generalized form of runtime dependence graph computed by abstract dynamic slicing, a semantics-aware technique that achieves high scalability by performing dynamic slicing over bounded abstract domains. The framework is instantiated to create two independent dynamic analyses, copy profiling and cost-benefit analysis, that help programmers identify performance bottlenecks by identifying, respectively, high-volume copy activities and data structures that have high construction cost but low benefit for the forward execution.We have successfully applied these analyses to large-scale and long-running Java applications. We show that both analyses are effective at detecting inefficient operations that can be optimized for better performance. We also demonstrate that the general framework is flexible enough to be instantiated for dynamic analyses in a variety of application domains.

show abstract

“…Brainy [5] and Chameleon [11] are examples of the first approach, they collect data during test runs which is then used to make an informed decision on which collection implementation to use in production code. CoCo [13] and Storage Strategies [1] are examples of the online, dynamic approach.…”

Section: Related Workmentioning

confidence: 99%

Data interface + algorithms = efficient programs

Wael

Marr

Meuter

2014

Proceedings of the 9th International Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Progra

View full text Add to dashboard Cite

Finding the right algorithm-data structure combination is easy, but finding the right data structure for a set of algorithms is much less trivial. Moreover, using the same data representation throughout the whole program might be sub-optimal. Depending on several factors, often only known at runtime, some programs benefit from changing the data representation during execution. In this position paper we introduce the idea of Just-In-Time data structures, a combination of a data interface and a set of concrete data representations with different performance characteristics. These Just-InTime data structures can dynamically swap their internal data representation when the cost of swapping is payed back many times in the remainder of the computation. To make Just-In-Time data structures work, research is needed at three fronts: 1. We need to better understand the synergy between different data representations and algorithms; 2. We need a structured approach to handle the transitions between data representations; 3. We need descriptive programming constructs to express which representation fits a program fragment best. Combined, this research will result in a structured programming approach where separating data interface from data representation, not only improves understandability and maintainability, but also improves performance through automated transitions of data representation.

show abstract

CoCo: Sound and Adaptive Replacement of Java Collections

Cited by 49 publications

References 28 publications

Applying Optimizations for Dynamically-typed Languages to Java

Applying Optimizations for Dynamically-typed Languages to Java

Scalable Runtime Bloat Detection Using Abstract Dynamic Slicing

Data interface + algorithms = efficient programs

Contact Info

Product

Resources

About