Four Open64 Projects Are Selected by Google Summer of Code 2008
2008 is the first year that Open64 joins Google Summer of Code. We got four projects selected and funded by Google in the coming summer. The projects are ...
Open64 joined Google Summer of Code in Mar. 2008. This is the first year that Open64 community takes part in this big event. See http://code.google.com/soc/2008/ and http://code.google.com/soc/2008/open64/about.html.
We have collected 14 ideas (http://www.open64.net/events/gsoc08.html) and got 23 applications. After discussion by the Open64 steering committee (http://www.open64.net/osg.html), we submitted 5 applications to Google and got 4 approved. Below are the brief introduction of these projects and also the names of the student&mentor.
1. Implementation of a static analysis phase for detecting potential memory leaking and duplicate free bugs
Student: Feng Zhou
Mentor: Handong Ye
Abs.: In a language that doesn't provide garbage collection support/facilities,
such as C, C++, programmers are required to manage memory themselves.
However, this may cause some problems, such as duplicate free of same
memory region, memory leaking, etc. There are some tools that can help
programmers debug this program. However, many of them requires programmers
to run the programs. Also, the detection result highly depends on the input
and behavior of the program. Statically detecting memory leaks has been
extensively studied in research community, such as: "Practical Memory Leak
Detection using Guarded Value-Flow Analysis" (Sigmund Cherem Lonnie
Princehouse Radu Rugina PLDI' 07). However, Open64 compiler currently
does not have any phases for memory safety detection. This project seeks
to implement one of the static analysis techniques for detecting memory
leaking, so that potential memory leaking/duplicate free problems can be
detected at compilation time. The advantage with this is that programmers
can be informed of possible memory operation issues at compile-time.
2. Advanced dead function elimination
Student: Chris Adamopoulos
Mentor: Gan, Ge
Abs.: Open64 Dead Function Elimination suffers from the fact that all virtual
functions are address exposed via virtual tables. In this project, class
hierarchy analysis and determination of the possible set of overrider functions
for a class hierarchy needs to be performed. Based on this analysis, Dead
Function Elimination can be made much sharper than it is today.
3. Implementation of New LNO Heuristics and Cost Models on X8664
Student: Chuntao Hong
Mentor: Robert Hundt
Abs.: Heuristics play an essential role in LNO. However, the heuristics and
the models implemented in Open64 are implemented long ago. Computer
architecture, especially the x86 architecture, has come a long way since
then. We now have powerful Out Of Order (OOO) units, deep pipeline, and
more registers on X8664. As a result, the old models in Open64 cannot
reflect the characteristics of the new architecture, causing the heuristics to
give wrong decisions. Through implementing new heuristics and cost models,
we can better leverage the power of new X8664 CPUs, and make the
Open64 compiler more powerful.
4. Function/Loop Specific Optimization
Student: Eun Jung Park
Mentor: John Cavazos
Abs.: Nowadays, compilers have a plethora of optimizations that would
confuse most users. Specific combinations of these optimizations can
increase performance, reduce power consumption, reduce code size,
or improve all of these metrics. However, good combinations are difficult
to find since the space of optimizations can be enormous. Because
of this, many researchers have focused on finding the best combination
of optimizations or a good ordering of them given a specific architecture
and application. However, previously proposed techniques have involved
search (therefore are expensive) and require user-intervention. It remains
an open problem to find the best set of optimization and ordering of
these optimizations efficiently. This project focuses on finding a good
ordering of optimizations for real-world applications, for example,
bioinformatics, financial, and data-mining applications. Our techniques
will be designed to be portable across a wide range of applications and
architectures and it will use machine learning algorithms to learn good
optimization orderings. Just as a human can learn how to solve complex
problems, this project will develop a machine learning framework to use
important characteristics of applications and hardware to help the
compiler find the best combination and orderings of optimizations.
This project will use several bioinformatics, data mining, and financial
applications compiled using the Open64 compiler targeted to different
architectures, including IA64 and X86-64.