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

Speaker:	Guoqing (Harry) Xu
		Ohio State University

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

Date:		Monday, 18 April 2011

Time:		4:00pm - 5:00pm

Venue:		Lecture Theatre F (near lifts 25/26), HKUST

Abstract:

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 skilful 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.


******************
Biography:

Guoqing (Harry) Xu is a Ph.D. candidate at the Ohio State University. His
research interests are programming languages, compilers, software
engineering, and runtime systems, and in particular, static and dynamic
program analysis techniques and their applications. During his Ph.D.
studies, he has interned twice in IBM T.J.  Watson research center and
worked closely with IBM researchers on projects related to performance
optimization and JVM technology. Major awards that he has received include
an IBM Research Ph.D. fellowship, a distinguished research award at the
Ohio State computer science department, an ACM SIGSOFT distinguished paper
award at ICSE'08, and a distinguished university fellowship at Ohio State.