About SEG
SEG News
SEG Seminar
Internal Site
Hot Link
Contact SEG
Academic lecture from Dr. Guoqing Xu

Title: Analyzing Large-Scale Object-Oriented Software to Find, Remove, and Prevent Runtime Bloat

Presenter: Dr. Qingguo Xu

Time: 14:00PM Jun 18, 2012 

Location: Room 230, CS Building, Xianlin Campus



    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 prolife ration 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. Compile (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 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. All the end of the talk, I will give plans for my future work.