Finding reusable data structures

XuGuoqing,

doi:10.1145/2398857.2384690

Cited by 19 publications

(48 citation statements)

References 70 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In this combo, both the LinkedList (List 0) and the ArrayList (List 1) have abstractions (i.e., placeholders) and concrete elements. For example, the abstraction 1, [2,3] is the placeholder of the No.2 and No.3 elements and it specifies that these two elements are currently in List 1. Different abstractions can be defined by creating different AbstractElement classes (in Figure 4).…”

Section: Fig 4 An Abstraction-concretization Example In Linkedlistmentioning

confidence: 99%

“…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%

“…A great deal of evidence [1,2,3,4,5] suggests that these problems are primarily caused by run-time bloat [6]-excessive memory usage and computation to accomplish simple tasks-often from inappropriate design/implementation choices (e.g., creating general APIs to facilitate reuse, using general implementations without any specialization, etc.) that exist throughout the program.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

CoCo: Sound and Adaptive Replacement of Java Collections

2013

ECOOP 2013 – Object-Oriented Programming

Self Cite

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

Section: Fig 4 An Abstraction-concretization Example In Linkedlistmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

CoCo: Sound and Adaptive Replacement of Java Collections

2013

ECOOP 2013 – Object-Oriented Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…Previous studies such as [6,7] have demonstrated that, in many cases, manual tuning with developers' insight can be much more effective than fully-automated compiler optimizations. For instance, a programmer may quickly identify that it is problematic to create a 100-field data structure in a loop with only 1 field iteration-dependent, while the sound transformation would give up and terminate silently.…”

Section: Computing Hoistability Measurementsmentioning

confidence: 99%

“…The approach from [18] dynamically identifies inappropriately-used Java collections to detect bloat. Recent work proposes dynamic analyses [6,7] that detect memory bloat by profiling copy chains and finding low-utility data structures, and static analysis [9] that finds inefficiently-used data structures. A detailed overview of the causes of runtime bloat can be found in [19,20].…”

Section: Related Workmentioning

confidence: 99%

Static Detection of Loop-Invariant Data Structures

Yan

Rountev

2012

ECOOP 2012 – Object-Oriented Programming

Self Cite

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

A Survey of Semantics-Aware Performance Optimization for Data-Intensive Computing

Rao

Wang

2017

2017 IEEE 15th Intl Conf on Dependable, Autonomic and Secure Computing, 15th Intl Conf on Pervasive Intelligence and Computing,

View full text Add to dashboard Cite

We are living in the era of Big Data and witnessing the explosion of data. Given that the limitation of CPU and I/O in a single computer, the mainstream approach to scalability is to distribute computations among a large number of processing nodes in a cluster or cloud. This paradigm gives rise to the term of data-intensive computing, which denotes a data parallel approach to process massive volume of data. Through the efforts of different disciplines, several promising programming models and a few platforms have been proposed for dataintensive computing, such as MapReduce, Hadoop, Apache Spark and Dyrad. Even though a large body of research work has being proposed to improve overall performance of these platforms, there is still a gap between the actual performance demand and the capability of current commodity systems. This paper is aimed to provide a comprehensive understanding about current semantics-aware approaches to improve the performance of data-intensive computing. We first introduce common characteristics and paradigm shifts in the evolution of data-intensive computing, as well as contemporary programming models and technologies. We then propose four kinds of performance defects and survey the state-of-the-art semantics-aware techniques. Finally, we discuss the research challenges and opportunities in the field of semantics-aware performance optimization for data-intensive computing.

show abstract

Finding reusable data structures

Cited by 19 publications

References 70 publications

CoCo: Sound and Adaptive Replacement of Java Collections

CoCo: Sound and Adaptive Replacement of Java Collections

Static Detection of Loop-Invariant Data Structures

A Survey of Semantics-Aware Performance Optimization for Data-Intensive Computing

Contact Info

Product

Resources

About