1. Source 2 Source Optimizations


Each optimization is accompanied by an appropriate GUI which:

1.     displays the relevant source code area to be optimized such as:

frequently executed loops

frequently accessed fields of classes/structures


2.    lists the optimization options and parameters to choose from

3.    lists the criteria needed for applying the optimization:

variable must not be modified outside the scope of the loop

for the optimization of reusing temporary computations

there should be no references to a field element outside the module

for class splitting optimization


4.    transforms the code under user authorization

The optimized source code can be revisited by the user, i.e.:

1.    the transformed code includes proper documentation

2.    the user has the option to accept or reject the transformed code based on the provided criteria list


For more information press here



2. Source comments and Code Refactoring in Java/C++ for GPGPU


A new trend in high performance computing is now taking place in industry with the emergence of General Purpose Graphical Processing Units (GPGPU). By taking frequently executed code parts and translating them to run on GPGPU processors, developers are able to improve performance speedups significantly. The project is to identify code patterns in Eclipse JDT or Eclipse CDT which can be optimized and improved and then to provide a relevant comment on its optimization and parallelization potential. For some code patterns, a code refactoring option can enable users to change the code automatically. Each project will include a different set of comments/refactoring for implementation in JDT or CDT.


How can source optimizations be implemented in Java or C++?


The JDT and CDT pulgins of Eclipse include an important feature called "Code Refactoring" which enables Java/C++ programmers to apply complicated transformations at source level. A The Code Refactoring feature can be extended to implement and apply various profile-based source-level optimizations in order to produce optimized programs which run faster and consume less power. A Code refactoring is the process of modifying a program's source code while preserving the existing functionality and semantics as part of the development cycle. For example, highly used refactoring options include pulling up or pushing down classes in the inheritance graph and modifying all the places in the code that are affected by it.


The Eclipse JDT and C++ plugins are open source Interactive Development Environment (IDE) with a built-in incremental compiler. It operates on entire projects, each consisting of a multiple of Java classes and files and supports advanced refactoring options and code analysis. The refactoring is provided in the JDT/CDT plugin as an option in the main perspective by selecting an area in the displayed Java code and then choosing it from a menu-bar of possible refactoring operations. Once selected, the refactoring is applied on all the Java files in the project respectively, displaying the code before and after the refactoring. Pressing the Apply button will cause the refactoring transformation to get committed on the project code.


Apart from the JDT/CDT plugin, the Eclipse environment includes other plugins such as the TPTP (Test and Performance Tools Platform) plugin for collecting and using profile information. This information is needed in order to guide the developer in focusing on the Hot classes which are most suitable for optimization.

Eclipse JDT Code Advisor: http://jdt-comments.appspot.com

Eclipse CDT Code Advisor: https://sites.google.com/site/codeadvisorproject/


3.                Dynammic binary instrumentation to improve performance of running applications.

Pin is a tool for the dynamic instrumentation of programs. It supports Linux binary executables for Intel (R) Xscale (R), IA-32, Intel64 (64 bit x86), and Itanium (R) processors; Windows executables for IA-32 and Intel64; and MacOS executables for IA-32. Pin was designed to provide functionality similar to the popular ATOM toolkit for Compaq's Tru64 Unix on Alpha, i.e. arbitrary code (written in C or C++) can be injected at arbitrary places in the executable. Unlike Atom, Pin does not instrument an executable statically by rewriting it, but rather adds the code dynamically while the executable is running. This also makes it possible to attach Pin to an already running process.

The API. Pin provides a rich API that abstracts away the underlying instruction set idiosyncrasies and allows context information such as register contents to be passed to the injected code as parameters. Pin automatically saves and restores the registers that are overwritten by the injected code so the application continues to work. Limited access to symbol and debug information is available as well.

For more information press here




Dr. Gad Haber from the IBM Haifa research lab
Home page: