Duration: 1:10:10

56 views

3

Over the past decade, the pervasive use of advanced object-oriented languages like Java and the increasing complexity of tasks accomplished by software have led to the proliferation of large framework-intensive applications. These applications are typically built from integrating numerous layers of middleware, libraries and frameworks. While employing these libraries and frameworks eases the development effort, this reliance on code reuse comes at a cost. Many applications suffer from excessive memory footprint, which is caused by chronic runtime bloat. Bloat impacts significantly the scalability and performance of real-world object-oriented applications that form the backbone of modern enterprise computing. Compilers (e.g. the JIT compiler in a JVM) are usually ineffective in optimizing bloat away as layers of abstractions grow to be deep and dynamic. Tuning is a daunting task performed mostly manually by only a handful of skillful experts, and it is extremely labor-intensive and time-consuming. The central goal of my thesis research is to develop program analysis techniques to make tuning easier, and in particular to help programmers quickly find, remove, and prevent runtime bloat. In this talk, I will focus on two particular program analysis techniques that can help programmers quickly find and remove bloat. The first technique is a JVM-based dynamic analysis that identifies low-utility data structures by looking for operations that have high costs and low benefits. These data structures are usually strong indicators of performance problems. Using this analysis, we have found large optimization opportunities in real-world applications and classified many bloat patterns that can be regularly observed during executions. One such bloat pattern is constructing and initializing data structures that are invariant across loop iterations. The second technique that I am going to talk about is a static analysis that attempts to (a) automatically hoist such invariant data structures out of loops, and (b) report them to the developer if it is not straightforward to hoist them. We have achieved significant performance gains (e.g., as large as 82.1 running time reduction) by hoisting loop-invariant data structures in real-world large Java applications. At the end of the talk, I will give plans for my future work.