Readme For
Open Research Compiler Release 1.0.0
Contents
How to download pre-built
compilers and
install
How
to download and build compiler source
Known problems and
limitations
How to report bugs and
get support
Appendix A Brief
descriptions on Pro64 compiler
The
ORC compilers, based on the SGI
Pro64™* compiler suite, include optimizing compilers
and runtime support for C, C++, and Fortran90. These compilers produce code that
follows the Linux/IA-64 ABI. This
means that objects produced by the ORC compilers can link with objects produced
by other Linux/IA-64 compliant compilers such as RedHat/Cygnus gcc and g++.
The
latest information and update for the ORC compilers can be found in http://sourceforge.net/projects/ipf-orc. The packages included in this
distribution represent a work in progress.
Please
send problem reports to http://sourceforge.net/projects/ipf-orc web site.
The
compilers include all optimizations performed by the Pro64™ compiler. For a more detailed description of existing Pro64™ highlights and optimizations, please refer to the readme file of
the Pro64™ compilers release. A portion of that is included
as Appendix A.
A number of research infrastructure features and Itanium™ processor family optimizations have been added. The infrastructure features include:
- Region-based optimization framework,
the notion of region is introduced
into CG and many phases are made aware of and performed under it.
- Parameterized machine model,
it encapsulate micro-architectural
details and can be easily reconfigured to study the impact of different
configurations.
- Support of profiling feedback at code generator,
some common
profiling support are provided to allow researchers to construct various
profiling, e.g. path profiling, value profiling, memory profiling, etc.
The newly designed Itanium™ processor family specific optimizations include:
- If-conversion (predication)
- Control and data
speculation with recovery code generation
- Predicate analysis to support predicate-aware data flow analysis
- Global Instruction scheduling integrated with template selection
The ORC specific features
replace those provided by the Pro64™. When the ORC
compilers are invoked, the optimizations mentioned above will be performed by default at
–O2 or above, and can be turned off
separately or entirely. Other
optimizations in the Pro64™ compilers will still be performed.
(Note: profile feedback at the code generator provided by ORC does not replace
the profiling scheme provided in Pro64™. It is designed to
complement and extend the original scheme.)
There
is a FAQ for the ORC compiler. More information can be found there.
How
to download pre-built
compilers and install
Download following file
from
this URL:
http://prdownloads.sourceforge.net/ipf-orc/orc-1.0.0.tgz
The
ORC compilers, like the Pro64™ compilers assume to be operating under an NUE
environment. Information about NUE
can be found at:
http://www.software.hp.com/ia64linux
To install the ORC compilers:
For installation under NUE on an IA32 machine:
% nue
# tar zxvf orc-1.0.0.tgz
# ./install-bin.sh
Note that the nue command will put you under your home directory in NUE, which may not be your regular home directory. You should make sure that the ORC binaries are under a directory that is accessible under NUE.
For installation on an Itanium™ machine:
%su
#./install-bin.sh
You
can verify your installation by doing a simple “hello world” test under NUE or
the Itanium™ machine:
%cat hello.c
#include
<stdio.h>
main()
{
printf("hello world\n");
}
%orcc hello.c
%./a.out
hello world!
%
Some users might find it more convenient to do cross compilation on an IA32 machine under NUE and run the binaries on an Itanium™ machine. To do that, we recommend that you generate the object files (.o’s) under NUE, transfer the objects files to the Itanium™ machines, link the .o’s, produce the binary there and run it, as follows:
1. At IA32 side:
[IA32]% orcc -c hello.c -o hello.o
[IA32]% ftp IA64
(transfer hello.o
to machine IA64)
2. At IA64 side:
[IA64]% orcc hello.o -o hello
[IA64]% ../hello
hello world!
%
How To Download And Build Compiler Source
Download the ORC source:
You need to download the the original Pro64™ source code and unpack it to a directory first. For convenience, a copy can be found here:pro64-0.01.0-13-sources.tar.gz.
Download the package containing the whole ORC sources and other necessary files:orc-1.0.0-sources.tgz. This package includes:
files modified from Pro64™ source: orc-1.0.0-modified.tgz.
files from Intel: orc-1.0.0-intel.tgz.
files from Institute of Computing Technologies, Chinese Academy of Sciences: orc-1.0.0-ict.tgz.
files for the test environment: orc-1.0.0-test-env.tgz.
installation scripts and license files.
Install the ORC source:
% cd download-directory
% tar zxvf orc-1.0.0-sources.tgz
% ./install.sh (You will be prompted for license information and installation directory)
The ORC source will be added to the original Pro64 source. Some of the original source file and makefiles will be overwritten.
Build the compiler under IA32 machine
Prerequisites:
We used the following version of gcc to compile the binaries
included in our rpm:
gcc version
2.95.2 19991024 (release)
Build optimized compiler
If compile time is important to you, you can build the compiler (or parts of the components) with optimized option and with all verification turned off. This is the default setting in the source package. If the default configuration has been changed, you can do as following:
1. modify file osprey1.o/Makefile.gsetup and set the value of the variable OPTIMIZER to what you want under DEBUG and NODEBUG branch (say, -O2 under NODEBUG branch).
2. You need to make sure the value of the variable BUILD_OPTIMIZE in each sub-makefiles is DEBUG or NODEBUG, e.g. if you want to control be build, you need to check osprey1.0/targia32_ia64_nodebug/be/Makefile for setting BUILD_OPTIMIZE to DEBUG or NODEBUG
3. #undef Is_True_On in osprey1.0/common/ipfe_targ_info/access/ekapi_ia64.h
Build non-optimized compiler
If you need to debug one or more of the compiler components, you can turn on the verification capability of the compiler and build it with debug option by changing the corresponding files. For example, if you want to debug the backend and the code generator, you can set the variable BUILD_OPTIMIZE in both osprey1.0/targia32_ia64_nodebug/be/Makefile and
osprey1.0/targia32_ia64_nodebug/cg/Makefile to DEBUG. This will allow you to have be.so and cg.so with symbol debugging capability while the other components in optimized format.
Building
other components with debug option will be similar.
Detailed description of the actual build of
each individual components is the same as described in the readme file in 0.13
release of Pro64™.
Please see Appendix B for
reference.
Known
Problems and limitations
We have tested the compilers to the best of our knowledge. The following are known problems or areas that we have not done extensive testing:
1. With IPA turned on, some of the CPU2000 integer benchmarks failed.
2. We have not tested IPA with CPU2000 fp benchmarks.
A full description of each known problem is listed in Appendix C.
How
to report bugs and get support
Bugs
can be reported via Sourceforge in
the ORC
Support Request tracker. In order to respond quickly to your problem, we request the
following information be entered in the bug report by using the "Submit New" form in the tracker:
Category
From the pull-down list, select one item that best describes the bug on your judgment.
Currently the list is as follow:None
Assertion failure
Compilation crashed
Correctness defect
Feature request
Installation
Performance defect
ToolsGroup
Please select V1.0.0eval at this moment.
Summary
Please give a brief description of the problem in this field.
Detailed description
Compilation options.
Commands to execute application if it's an runtime error.
Symptom descriptions.Files if any that will help repeat the problem:
Source code. It would be better that the file is preprocessed. This would reduce the problem caused by included files in the code.
Other input files such as data files needed by the application.
For
issues with installation and usage of the compiler, we request that users first
go through the mail alias ipf-orc-support@lists.sourceforge.net.
This
will help us respond to the issues in a more timely fashion without dropping
anyone. We
also strongly suggest you to sign onto the ipf-orc-support@lists.sourceforge.
For issues related to the Pro64™ compiler, please
go to mailing list open64-devel@lists.sourceforge.net.
The
following is extracted from the readme file of the Pro64
compilers:
Language highlights:
C compatible with gcc
C++ compatible g++
Fortran90 with Fortran95 extensions
Optimization highlights:
Software pipelining:
At the -O2 and -O3 optimization levels the compilers will use the IA-64 software pipelining instructions.
At the -O3 level a more powerful data dependence analysis will be performed.
Scalar optimization:
A partial list of optimizations performed include
Code motion
Constant propagation
Dead code elimination
Expression simplification
Common subexpression elimination
Strength reduction