Compare with Previous | Blame | View Log
Open64 Compiler Version 4.2 Release Notes
Sep 30, 2008
1. Overview
2. Features
2.1 Front End Features
2.2 Back End Features
3. The Packages of the Compiler Suite
4. Installing the Compiler Suite
4.1 Install from bz2 Package
4.2 Install from RPM packages
5. Build the compiler Suite - directly from source
5.1 Prerequisites
5.2 Build Steps
5.3 Build FORTRAN Front-End
5.4 Build the archives
5.5 Some Notes on Build
6. Bug Reporting
7. Known Problems, Limitation and Some Notes
8. Acknowledgements
1. Overview
=============
Open64 is an open source, optimizing compiler for multiple architectures.
Open64 supports Fortran 77/95/2003 and C/C++, as well as the shared memory
programming model OpenMP. Open64 derives from the SGI compilers for the MIPS
called MIPSPro. It was released under the GNU GPL in 2000. The initial release
of Open64 only supports Intel IA-64(Itanium). Now it has been extended to
generate code for CISC, RISC, VLIW architectures, including x86, MIPS, IA-64
and others.
The objective of the Osprey project is to bring the Open64 compiler
to that of a production quality compiler and catch up with the GCC/G++
features evolution. This release was merged with PathScale 3.2 release.
Thanks to this PathScale release, GCC 4.2 based FE is enabled and works
for IA64 also. We improved the performance, integrated many bug fixes
by leveraging efforts from PathScale, NVIDIA and SimpLight. We also
enhanced the scalability, capability and correctness of IPA.
It is worth noting that several new code generators and programming
system are integrated into this release, including CUDA from NVIDIA,
SL (a 32-bit multi-threaded architecture for embedded systems and DSP
in telecommunications) from SimpLight, MIPS (prototype) from ICT with
input from both PathScale and SimpLight.
The source code of the latest release and all previous archives can be
found in the subversion tree and it is readily available for researchers
and developers to join the development and incrementally check in changes.
The website for that is
http://www.open64.net/
The release consists of two kinds of packages: a suite of pre-built
compiler binaries including C, C++, F95 and related archives, and
a suite of corresponding compiler source codes. The pre-built compilers
are built using a self-build bootstrap process. They are provided both in
.bz2 and RPM packages. These files can be downloaded from sourceforge.net:
http://sourceforge.net/project/showfiles.php?group_id=34861
After this release, we will continue to update the GCC/G++ front end to the
latest version, improve the quality and scalability. Another important
focus after this release is further performance improvement to follow the
latest CPU and architecture evolution, especially for the multicore. Besides
this, Open64 based static analysis tool, runtime optimization framework,
security checking tool are highly expected.
We are looking forward for collaboration from the open source community
for this effort. The SVN source control and Bugzilla system are built up
to facilitate this. Our check-in testing will be continuously improved
to achieve the "check-in early and check-in fast with little to no impact
to overall quality" development environment.
For a more detailed description of the quality and performance of the compiler,
please visit Open64 website:
http://www.open64.net
2. Features
=============
2.1 Front End Features
-------------------
Open64 C/C++ Front End is based on GNU C/C++ Compiler (GCC). The C/C++ Front
End provides the compatibility with GCC from 3.x to latest 4.x. Open64 FORTRAN
Front End is based on CRAY-FORTRAN, which supports FORTRAN 77/95/2003 and CRAY
extensions.
In this release, we enabled the GCC 4.2.0 based FE to get better compatibility
with the latest GCC revision. Several bugs in previous GCC 3.3.1 and 4.0.2
based FE are also fixed.
Now the compiler contains three different GCC based front-ends:
o. GCC 3.3.1 based FE
Provides the compatibility with GCC 3.x
o. GCC 4.0.2 based FE
Provides the compatibility with GCC 4.0.x
o. GCC 4.2.0 based FE
Provides the compatibility with GCC 4.1.x and above
The right FE will be chosen automatically based on the version of the GCC
on the host. The command line options: '-gnu3', '-gnu40' and '-gnu42', can
be used to designate the FE explicitly.
We also improve the conformance of the FORTRAN Front End for new FORTRAN
2003 features:
o. Using 'intent' and 'pointer' attributes together
o. 'volatile' attribute and declaration
2.2 Back End Features
-------------------
Open64 Back End contains several optimizers and code generator.
o. Interprocedural Analyzer and Optimizer (IPA)
o. Loop Nest Optimizer (LNO)
o. Global Optimizer (WOPT)
The Code Generator (CG) can generate code for several targets, including
IA-64, IA-32 and x86_64 and others.
In this release, we reduced the memory footprint of IPA to get better
scalability to enable building large C++ application with IPA. Also, we enhanced
the IPA to handle mixed archives which may contains both WHIRL IR files
and object files. Several bugs to build shared libraries (.so) with IPA are
also fixed. Besides IPA, Some bugs in LNO, WOPT and CG are fixed.
We also introduced several performance improvements in BE.
o. Better loop vectorization and loop factorization from PathScale
o. New dead store elimination (DSE) algorithm from SimpLight
o. Improved prefetch efficiency for ix86 and x86_64 from PathScale
o. Improved instruction scheduling for ix86 and x86_64 from PathScale
o. Better tuning for both AMD and Intel new multicore CPU from PathScale
Several new targets were also supported in this release besides IA-64, x86
and x86_64:
o. SL (an embedded DSP architecture) code generation from SimpLight
o. CUDA code generation from NVIDIA
o. A MIPS code generation prototype from ICT based on input from PathScale
and SimpLight
3. The Packages of the Compiler Suite
=============
This compiler is available in both binary and source-code form for
different target machines.
o. open64-4.2-0.src.tar.bz2
This package contains the compiler's source code. It's machine independent.
o. open64-4.2-0.ia64.tar.bz2
This package contains all the binary code for ia64 machine including
pre-built library. The compiler is built on an Itanium2 based system with
kernel 2.6.18 and glibc 2.5. The OS is RHEL5 on IA64. The GCC version
is 4.1.1. The compiler is built twice for releasing. The first stage
is built by open64 4.1 at '-O2', then we use the compiler built in the
first stage to build the release compiler at '-O2'. The libraries are built
by the release compiler.
o. open64-4.2-0.i386.tar.bz2, open64-4.2-0.x86_64.tar.bz2
These two packages are the same; contain all the binary code for i386 and
x86_64 machines. The compiler is built on an IA32 based system with
kernel 2.6.18 and glibc 2.5. The OS is RHEL5 on IA32. The compiler is
built twice for releasing. The first stage is built by Open64 4.1 at '-O2',
then we use the compiler built in the first stage to build the release
compiler at '-O2'. The 32-bit libraries are built on the same
system by this compiler.
The 64-bit libraries are built on an RHEL5 x86_84 system by this compiler.
o. open64-4.2-0.i386.rpm, open64-4.2-0.x86_64.rpm, open64-4.2-0.ia64.rpm
These three packages are binaries rpm for different targets. The binaries
are the same in both bz2 and rpm packages. It's easier to install the
compiler from the rpm.
4. Installing the Compiler Suite
=============
4.1 Install from bz2 Package
-------------------
Before installing the compiler, the environment variable $TOOLROOT
should be set properly. As the name suggests, this variable specifies
the root of the installation hierarchy. You can set it to anywhere
you have write permission. For example, in GNU BASH this may be done
with the following command: may set this variable by adding this
command to the $HOME/.bash_profile file:
export TOOLROOT=$HOME/mycompiler
After that, run 'source $HOME/.bash_profile' to make the change effective.
Now, to complete the installation:
o. Expand open64-4.2-0-ia64.tar.gz with the command:
tar zxvf open64-4.2-0-ia64.tar.gz
o. Run script 'INSTALL.sh'
The C, C++, FORTRAN compilers are now available in folder
$TOOLROOT/bin. They are opencc, openCC, openf90 respectively.
4.2 Install from RPM Package
-------------------
To install the compiler from rpm:
$ rpm -ivh open64-4.2-0.ia64.rpm
This command will install the Open64 compiler to /opt/open64. The C, C++,
FORTRAN compilers are in folder /opt/open64/bin.
To install the compiler to another location:
$ rpm --prefix=/path/to/folder -ivh open64-4.2-0.ia64.rpm
Then the compiler will be installed to /path/to/folder
5. Build the compiler Suite - directly from source
=============
If you choose to build the compiler suite from the source tar ball,
follow the steps outlined below.
5.1 Prerequisites
-------------------
In order to compile Open64 successfully, your system should meet the
following requirements:
o. Linux OS on IA64/ix86/x86_64
Open64 as well as its variants have been successfully built on many UNIX
variants and UNIX-like systems. This release has only been tested extensively
on IA64/ix86/x86_64 running Linux operating systems. If you are going to
build it on any platform other than Linux on IA64/ix86/x86_64, you may need
to make some minor changes to the source code.
o. Miscellaneous Tools
To build the open64 compiler from source, these tools are needed:
awk, csh, bash, gmake, flex and bison
On some Ubuntu distributions, you need to set the environment variable
'SHELL' to '/bin/bash' or change the symbol link '/bin/sh' to '/bin/bash'
to make the shell scripts work.
o. GNU Compiler Collection
Currently, GCC 3.3.x through 4.1.x are supported. GCC 4.1.x is preferred.
o. An open64 binary for building the FORTRAN Front End
You can just download the Open64 binary for system and install it to
some place and make sure that openf90 is in your PATH before building
the FORTRAN Front End.
Intel Fortran Compiler (on IA64/IA-32/x86_64) or PathScale Fortran Compiler
(on IA-32/x86_64) can also be used to build the FORTRAN Front End.
5.2 Build Steps
-------------------
Follow these steps to build the compiler:
Step 1. Expand the source tarball
After that, the whole source hierarchy will be in directory rooted at
open64-4.2-0/. Change working directory to open64-4.2-0/.
Step 2. Build the compiler components by simply invoking command:
make or make V=1(V=1 will show all building information)
If you want to build a debuggable compiler, use this command instead:
make BUILD_OPTIMIZE=DEBUG
Note that, if you type "make", it will only build the compiler's source
code by default it won't build the necessary libraries. If you want to
build them by yourself, type
make library
The default FORTRAN compiler in source code is openf90. If the openf90 is
not in the PATH, the FORTRAN front end will not be built. During the
installation, the pre-built version will be picked up. Then, we can use
it to build the FORTRAN front end again.
Developers may find this command handy in building individual component,
say wopt.so:
make BUILD_OPTIMIZE=DEBUG wopt.so
step 3. Set environment variable TOOLROOT to anywhere you have write
permission as detailed in section 3.
If you do not want to use $TOOLROOT, just skip this step.
step 4. Call 'make install' or 'install_compiler.sh' to install
all compiler components and archives.
If $TOOLROOT is set, the compiler will be installed to that folder.
Otherwise, a path will be prompted.
The C, C++, FORTRAN compilers are now available in folder
$TOOLROOT/bin/
They are opencc, openCC, openf90 respectively.
People interested in building the compiler for CUDA or SL should contact
NVIDIA or SimpLight directly.
5.3 Build FORTRAN Front-End
-------------------
The FORTRAN front-end executable is provided in both binary and source
packages. Normally, you need *NOT* to build it by yourself. If you are
going to build one, make sure that an Openf90 is already in your $PATH
(you need to download a binary form and install it somewhere).
Then just type:
make mfef95.
The Makefile will use a pre-hand openf90 to build the new mfef95 for you.
5.4 Build the archives
-------------------
The archives required by Open64 are provided in both binary and source
packages. Normally, you need *NOT* to build it by yourself. These libraries
can be built by Open64. Add $TOOLROOT/bin into your $PATH and type:
make BUILD_COMPILER=OSP lib
Then, you can follow the step 3 and step 4 in section 5.2 to install these
archives.
5.5 Some Notes on Build
-------------------
o. The compiler is built with flag '-Werror' which treats warnings as error.
If the build process terminates due to warnings, you can get around this
with:
make ... ERROR_ON_WARNINGS="" ...
i.e. simply repeat the make process with ERROR_ON_WARNINGS="".
6. Bug Reporting
=============
You are WELCOME to report bugs. The bugs tracked at
http://bugs.open64.net/.
Bug reports should include these items in order to be reproduced:
o. The compiler release version;
o. System details -- the OS, libc etc;
o. The compilation flags that trigger the bug;
o. The test file if applicable (it is highly appreciated if the test file
is minimized);
o. The correct output of the test file.
7. Known Problems, Limitation and Some Notes
=============
o. Currently, we built the compiler *ONLY* on Linux/IA64, x86_64, i386.
'make cross' is supposed to be used to build the cross compiler on
Linux/IA32 systems targeting IA64. However, we have not tested this
thoroughly.
o. On x86_64, Open64 can be built in either 32-bit or 64-bit. We find
several bugs in building 32-bit applications by 64-bit compiler. All
executables in Open64 4.2 binary release on x86_64 are 32-bit. These bugs
will be fixed in the next release.
o. Auto-Parallel Optimization (enabled by '-apo') has been implemented in the
compiler. But now it does not work. We will fix this problem in the next
release.
o. The perlbench benchmark in CPU2006 suite may not run successfully without
some changes to its source code on IA-64. It is *NOT* an Open64 bug.
The problem is with the perlbench benchmark itself. Please check the bug-81
(https://bugs.open64.net/) for details. This problem can be solved by
deleting following lines from file spec_config.h (of perlbench benchmark):
1172 #undef HASATTRIBUTE
1173 #ifndef HASATTRIBUTE
1174 #define __attribute__(_arg_)
1175 #endif
o. A full list of known bugs can be found in our bug database. You can visit
http://bugs.open64.net
to view them.
8. Acknowledgements
=============
This project is led by Shin-Ming Liu at HP Inc. It is the result of
partnership between these academies and companies:
o. Tsinghua University
o. CAPSL research laboratory at the University of Delaware
o. NVIDIA Inc.
o. SimpLight Nanoelectronics Inc.
o. Hewlett-Packard Inc.
o. Institute of Computing Technology (ICT) at the Chinese Academy of Science
We upgraded the GCC front end in Open64 by leveraging PathScale's effort.
We also got a lot of suggestions, bug fixes, especially the performance
enhancements from Fred Chow and others in PathScale Inc. Their help is
greatly appreciated.
Thanks all of the Pro64 developers, the ORC developers and ORC/Open64 users.
In this release, Cui Huimin at ICT did the prototype of MIPS retarget based on
input from PathScale and SimpLight.
The following individuals also contributed a lot to our previous releases:
o. Paul Yuan at Peking University