³ 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
±
etc.
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
± etc
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
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/
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
gadi.haber@intel.com
Home page: http://cs.haifa.ac.il/courses/java/gadi.html