Note This page is deprecated in favor of https://hpc.llnl.gov/software/development-environment-software/compilers.
Numerous compilers are available to provide a rich programming environment for scientific and technical computing. A detailed list of single CPU, distributed memory, and shared memory compilers and their machine availability is provided below.
The LC Hotline will provide assistance if your code will not compile. Assistance is also available if you need to port your code to another platform.
GNU Make controls the generation of executables and other non-source files of a program from the program's source files. It is located in /usr/local/bin/gmake. PMAKE is a non-supported parallel MPI version of GNU Make.
Compilers Installed on LC Platforms
As of 07/22/16
Platform Links | Documentation | Defaults | Version Notes | Additional Notes
Platform Links
| OCF x86_64 CHAOS 5 | ansel, aztec, borax, cab, catalyst, edge, herd, rzalastor, rzcereal, rzgpu, rzmerl, rzzeus, sierra, surface, syrah |
| SCF x86_64 CHAOS 5 | agate, inca, juno, max, muir, zin |
| ISNSI x86_64 CHAOS 5 | pinot |
| OCF IBM BG/Q | rzuseq, vulcan |
| SCF IBM BG/Q | seq |
Compiler Documentation
- xlf
- xlc/xlC
- GNU
- Intel 16.0 C/C++
- Intel 16.0 Fortran
- PGI
Default Compilers and Versions by Platform
Alternate Compiler Versions
Modifying Default Compiler Versions with Dotkit
Default compiler versions can be modified using Dotkit. Dotkit starts up by default at login time on all CHAOS Linux machines. To load a Dotkit package, use the use command. For example, running use ic-9.1.052 will cause the icc, ifort, mpiicpc, etc. commands to invoke the 9.1.052 version of the Intel compilers. Note that Dotkit works by modifying environment variables, thus the changes are only valid for the session in which the use command was invoked. These changes can be made persistent by invoking the Dotkit in your startup script, in which case it is suggested to run use -q to run Dotkit in quiet mode. To view available compiler Dotkits run the use -l compilers command. More information about Dotkit can be found on LC's Dotkit page.
Alternate compiler versions
Older and newer versions of all compilers (including MPI wrappers) are available through version specific names such as ifort-12.1.339 and mpipgcc-7.1.3. LC provides a utility to see a full list of available compiler commands. This utility is available via the compilers command. Specific queries, based on vendor, language, or parallelism model (serial or MPI), can be made to this utility. For query options, run compilers -h.
Additional Notes
Clang note
Various Clang installations have been made available. For more information, refer to the Clang wiki on the LC Confluence server.
SYS_TYPE note
Executables compiled on machines of one SYS_TYPE are not likely to run on machines of a different SYS_TYPE. The exception is that executables may run on both chaos_5_x86_64_ib and chaos_5_x86_64. Some software and libraries may be available for some SYS_TYPEs and not others. Some utilities and libraries may be in different places on machines of different SYS_TYPEs. You may need to modify your makefiles or build scripts when transitioning to a machine of a different SYS_TYPE.
GNU compiler note
Our GNU compilers on Linux systems are versions provided to us by RedHat, not vanilla versions available from GNU. They may perform differently or have different features than the vanilla GNU builds. Builds of GNU's versions of these compilers tend not to work on our Linux systems because of incompatibilities with binutils.
gfortran and g77 note
The GNU Fortran compiler command has changed between version 3, the CHAOS 3 default, and version 4, the CHAOS 4 default. On CHAOS 4 machines, and subsequently CHAOS 5 machines, the default GNU Fortran compiler is invoked with the gfortran command. If you use the g77 command on a CHAOS 5 system, you will get the non-default GNU Fortran compiler (version 3).
Pathscale note
As of CHAOS 5, LC no longer supports the Pathscale compilers.
CUDA note
The CUDA Toolkit is available on systems with compatible GPU accelerators. Information on how to build codes with CUDA can be found on LC's CUDA pages [deprecated as well].
OpenCL note
OpenCL is available on systems with GPU accelerators. Information on how to build codes with OpenCL can be found on LC's OpenCL pages. [deprecated as well.]
Vectorization with the Intel Compiler note
Vectorization is becoming increasingly important for performance on modern processors with widening SIMD units. More information on how to vectorize with the Intel compilers can be found on LC's vectorization page.
Static Security Analysis with the Intel Compiler note
The Intel Compiler includes a feature known as Static Security Analysis (SSA), which performs static analysis of source code to uncover security vulnerabilities and code correctness issues. More information how to use SSA with the Intel compilers can be found on LC's SSA page.
Intel compiler mixed language note
When calling a Fortran routine compiled with ifort from C or C++, it is recommended that you call the Intel-specific initialization and finalization routines, for_rtl_init_ and for_rtl_finish_. This is particularly important when using ifort runtime options such as -check all. For example, you will first need to declare the following functions:
void for_rtl_init_(int *, char **); int for_rtl_finish_();
(if using C++, you will need to declare them as extern "C"):
extern "C" {
void for_rtl_init_(int *, char **);
int for_rtl_ffffinish_();
};From your C or C++ main you will then need to initialize and finalize with these functions, for example:
int main(int argc, char **argv)
{
for_rtl_init_(&argc, argv);
/* your code here... */
int io_status = for_rtl_finish_();
return 0;
}Because these routines are Intel specific, you may want to encapsulate them within #ifdef directives for the Intel compiler defined macro __INTEL_COMPILER.