Code Compilation on Sapelo2
Where should I compile my code?
IMPORTANT: Please DO NOT compile source code on the login node. Instead, compile your code in an interactive session started with the interact command.
Code compilation can be done in an interactive session. To start an interactive session, first login into Sapelo2 and from there issue the interact command
interact
If you plan to run the code on an AMD node, you can start an interactive session on an AMD node to compile the code. To start an interactive on an AMD node, use the command
interact --constraint AMD
If you plan to run the code on an Intel node, you can start an interactive session on an Intel node to compile the code. To start an interactive on an Intel node, use the command
interact --constraint Intel
For detailed information on how to access the compute node interactively for code compilation, please see Running Jobs on Sapelo2.
Compilers
A number of Fortran and C/C++ compilers, as well as Java and scripting languages such as Perl and Python, are available on Sapelo2.
Summary of main Fortran and C/C++ compilers installed
| Portland Group (PGI) | Intel | GNU | OpenMPI | File extension | |
|---|---|---|---|---|---|
| Fortran77 | pgfortran | ifort | gfortran | mpif77 | .f |
| Fortran90 | pgfortran | ifort | gfortran | mpif90 | .f90 |
| Fortran95 | pgfortran | ifort | gfortran | mpifort | .f95 |
| Fortran2003 | pgfortran | ifort | gfortran | mpifort | .f |
| C | pgcc | icc | gcc | mpicc | .c |
| C++ | pgc++ | icpc | g++ | mpicxx | .C, .cpp, .cc |
The various compiler suites are provided by their environment modules.
GNU compiler suites
The following command will show all the modules that provide GCC compiler suites:
module spider GCC
Sample partial output of this command:
[shtsai@d2-13 ~]$ module spider GCC
-----------------------------------------------------------------------------------------------------------------
GCC:
-----------------------------------------------------------------------------------------------------------------
Description:
The GNU Compiler Collection includes front ends for C, C++, Objective-C, Fortran, Java, and Ada, as well as libraries for these languages (libstdc++, libgcj,...).
Versions:
GCC/8.3.0
GCC/10.2.0
GCC/11.2.0
GCC/11.3.0
GCC/12.2.0
Other possible modules matches:
GCCcore
-----------------------------------------------------------------------------------------------------------------
This output indicates that the following versions of GCC compilers are available:
- Version 8.3.0, with binutils 2.32, provided by the GCC/8.3.0 module, includes C, C++, and Fortran compilers.
- Version 10.2.0, with binutils 2.35, provided by the GCC/10.2.0 module, includes C, C++, and Fortran compilers.
- Version 11.2.0, with binutils 2.37, provided by the GCC/11.2.0 module, includes C, C++, and Fortran compilers.
- Version 11.3.0, with binutils 2.38, provided by the GCC/11.3.0 module, includes C, C++, and Fortran compilers.
- Version 12.2.0, with binutils 2.39, provided by the GCC/12.2.0 module, includes C, C++, and Fortran compilers.
We suggest that you run the module spider GCC command to check an updated list of GCC compilers available on the cluster.
Intel compiler suites
The following command will show all the modules that provide Intel compiler suites:
module spider intel-compilers
Sample output of this command
[shtsai@d2-13 ~]$ ml spider intel-compilers
-----------------------------------------------------------------------------------------------------------------
intel-compilers:
-----------------------------------------------------------------------------------------------------------------
Description:
Intel C, C++ & Fortran compilers (classic and oneAPI)
Versions:
intel-compilers/2021.4.0
intel-compilers/2022.1.0
intel-compilers/2022.2.1
intel-compilers/2023.1.0
-----------------------------------------------------------------------------------------------------------------
This output indicates that the following versions of the Intel compiler suites are available:
- Version 2021.4.0, provided by the intel-compilers/2021.4.0 module.
- Version 2022.1.0, provided by the intel-compilers/2022.1.0 module.
- Version 2022.2.1, provided by the intel-compilers/2022.2.1 module.
- Version 2023.1.0, provided by the intel-compilers/2023.1.0 module.
- Version 2019.5.281, provided by the iccifort/2019.5.281 module
We suggest that you run the module spider intel-compilers or module spider iccifort command to check an updated list of Intel compilers available on the cluster.
LLVM compiler suites
The following command will show all the modules that provide LLVM compilers:
module spider LLVM
Sample output of this command
[shtsai@d2-13 ~]$ module spider LLVM
------------------------------------------------------------------------------------------------------------------------------------
LLVM:
------------------------------------------------------------------------------------------------------------------------------------
Description:
The LLVM Core libraries provide a modern source- and target-independent optimizer, along with code generation support for many popular CPUs (as well as some less common ones!) These libraries are built around a well specified
code representation known as the LLVM intermediate representation ("LLVM IR"). The LLVM Core libraries are well documented, and it is particularly easy to invent your own language (or port an existing compiler) to use LLVM as an
optimizer and code generator.
Versions:
LLVM/12.0.1-GCCcore-11.2.0
LLVM/14.0.3-GCCcore-11.3.0
-----------------------------------------------------------------------------------------------------------------------------------
How to load a compiler module
To use any of the compiler suite, please first load the corresponding module. For example, to use the GNU 11.3.0 compiler suite, load the module with
module load GCC/11.3.0
Once this module is loaded the gcc, g++, and gfortran for GCC v. 11.3.0 will be available in your path.
Please note that you can only have one compiler module loaded at a time.
Some commonly used compiler options
PGI compiler suite (To be added on Sapelo2)
| Option | Description |
|---|---|
| -O0 | Specifies no optimization, recommended for code debugging |
| -O1 | Specifies local optimization |
| -O2 | Specifies global optimization (this is the default, same as using -O) |
| -O3 | Includes -O1, -O2 and more aggressive optimization. Use with care. |
| -fast | Chooses generally good optimization options for the platform. Type pgcc -fast -help to see the equivalent options. |
| -Mbounds | Performs runtime array bound check, recommended for code debugging |
| -g | Produces symbolic debug information in the object files. |
| -r8 | Interpret REAL variables as DOUBLE PRECISION. |
| -B | Allow C++ style comments in C source code; these begin with ‘//’ and continue until the end of the current line. pgcc only. |
| -Kieee | Perform floating-point operations in strict conformance with the IEEE 754 standard. The default compilation is -Knoieee, which uses faster but very slightly less accurate methods. |
| -mp | Interpret OpenMP directives to explicitly parallelize regions of code for execution by multiple threads |
| -acc | Enable OpenACC pragmas and directives to explicitly parallelize regions of code for execution by accelerator devices. Use with the -ta option |
NOTE When using optimization options, please check if your code becomes more efficient (in some cases optimization options will slow the code down) and if it still generates correct results. Many other compiler options are available. For more information on the PGI compilers, you can view the manual pages with the commands man pgf90, man pgcc, etc, after loading the PGI module.
Intel compiler suite
| Option | Description |
|---|---|
| -O0 | Specifies no optimization, recommended for code debugging |
| -O2 | Enables optimizations for speed. This is the generally recommended optimization level. |
| -O3 | Performs -O2 optimizations and more aggressive loop transformations. Use with care. |
| -fast | Chooses generally good optimization options for the platform. Type pgcc -fast -help to see the equivalent options. |
| -Mbounds | Performs runtime array bound check, recommended for code debugging |
GNU compiler suite
| Option | Description |
|---|---|
| -O0 | Specifies no optimization, recommended for code debugging |
| -O2 | Enables optimizations for speed. This is the generally recommended optimization level. |
| -O3 | Performs -O2 optimizations and more aggressive loop transformations. Use with care. |
| -std= | Determine the language standard. This option is currently only supported when compiling C or C++. |
| -fopenmp | Enable handling of OpenMP directives "#pragma omp" in C/C++ and "!$omp" in Fortran. |
| -fopenacc | Enable handling of OpenACC directives "#pragma acc" in C/C++ and "!$acc" in Fortran. |
| -Wpedantic | Issue all the warnings demanded by strict ISO C and ISO C++; reject all programs that use forbidden extensions, and some other programs that do not follow ISO C and ISO C++. |
| -Wall | This enables all the warnings about constructions that some users consider questionable. |
Compiler Toolchains
On Sapelo2 we use the EasyBuild framework to install software applications. The EasyBuild toolchains are also available for users to compile their own code. Each toolchain provides a compiler suite and some basic libraries, such as MPI, BLAS, LAPACK, FFTW, etc.
More information about compiler toolchains, please Available Toolchains and Toolchain Compatibility.
foss toolchains
Most software applications are installed with the foss toolchain, where foss is short for “Free and Open Source Software”.
The foss toolchain consists of:
- binutils (https://www.gnu.org/software/binutils/)
- the GNU Compiler Collection (GCC, https://gcc.gnu.org/), i.e. gcc (C), g++ (C++) and gfortran (Fortran)
- the Open MPI library (https://www.open-mpi.org/)
- the OpenBLAS (http://www.openblas.net/) + LAPACK (http://netlib.org/lapack) libraries
- the ScaLAPACK (http://netlib.org/scalapack) library is also included
- the FFTW library (http://fftw.org/)
You can check the foss toolchain modules that are installed on the cluster with the command
module spider foss
When you load a foss toolchain, all it components will be loaded. For example:
[shtsai@d2-13 ~]$ module list No modules loaded [shtsai@d2-13 ~]$ module load foss/2022a [shtsai@d2-13 ~]$ module list Currently Loaded Modules: 1) GCCcore/11.3.0 5) numactl/2.0.14-GCCcore-11.3.0 9) hwloc/2.7.1-GCCcore-11.3.0 13) libfabric/1.15.1-GCCcore-11.3.0 17) OpenBLAS/0.3.20-GCC-11.3.0 21) FFTW.MPI/3.3.10-gompi-2022a 2) zlib/1.2.12-GCCcore-11.3.0 6) XZ/5.2.5-GCCcore-11.3.0 10) OpenSSL/1.1 14) PMIx/4.1.2-GCCcore-11.3.0 18) FlexiBLAS/3.2.0-GCC-11.3.0 22) ScaLAPACK/2.2.0-gompi-2022a-fb 3) binutils/2.38-GCCcore-11.3.0 7) libxml2/2.9.13-GCCcore-11.3.0 11) libevent/2.1.12-GCCcore-11.3.0 15) UCC/1.0.0-GCCcore-11.3.0 19) FFTW/3.3.10-GCC-11.3.0 23) foss/2022a 4) GCC/11.3.0 8) libpciaccess/0.16-GCCcore-11.3.0 12) UCX/1.12.1-GCCcore-11.3.0 16) OpenMPI/4.1.4-GCC-11.3.0 20) gompi/2022a
intel toolchains
The intel toolchain consists of
- the Intel compiler suite
- the Intel MPI libraries
- the Intel Math Kernel Libraries (MKL)
You can check the intel toolchain modules that are installed on the cluster with the command
module spider intel
When you load an intel toolchain, all it components will be loaded. For example:
[shtsai@d2-13 ~]$ module list No modules loaded [shtsai@d2-13 ~]$ module load intel/2022a [shtsai@d2-13 ~]$ module list Currently Loaded Modules: 1) GCCcore/11.3.0 3) binutils/2.38-GCCcore-11.3.0 5) numactl/2.0.14-GCCcore-11.3.0 7) impi/2021.6.0-intel-compilers-2022.1.0 9) iimpi/2022a 11) intel/2022a 2) zlib/1.2.12-GCCcore-11.3.0 4) intel-compilers/2022.1.0 6) UCX/1.12.1-GCCcore-11.3.0 8) imkl/2022.1.0 10) imkl-FFTW/2022.1.0-iimpi-2022a
Linking with libraries
Some library packages are installed along with some compiler toolchains. Examples of these are OpenBLAS, MKL, FFTW, etc. Other libraries are installed as a separate module, for example, Boost and GSL.
If you want to compile a code that uses a library that is not included with compiler toolchain, you will have to load a library module that uses a compatible toolchain. For example, if you want to compile your code with GCC 11.3.0 (or with the foss/2022a toolchain), and you need to use GSL, you can load the GSL/2.7-GCC-11.3.0 module.
Also note that when you load a module for a library or an application, the full path to its installation directory will be stored in an environment variable called EBROOTNAME, where NAME is the name of the application or library. For example, when you load a GSL module, the directory where the GSL libraries are installed will be in an environment variable called EBROOTGSL.
For example:
[shtsai@d2-13 ~]$ module list No modules loaded [shtsai@d2-13 ~]$ module load GCC/11.3.0 [shtsai@d2-13 ~]$ echo $EBROOTGCC /apps/eb/GCCcore/11.3.0 [shtsai@d2-13 ~]$ echo $EBROOTGSL [shtsai@d2-13 ~]$ module load GSL/2.7-GCC-11.3.0 [shtsai@d2-13 ~]$ echo $EBROOTGSL /apps/eb/GSL/2.7-GCC-11.3.0 [shtsai@d2-13 ~]$
As shown in the example above, when you load an GSL module, an environment variable called EBROOTGSL is defined, and it points to the installation path for GSL.
When you compile your code, you can add the compiler option:
-I${EBROOTGSL}/include
and the linker option
-L${EBROOTGSL}/lib -lgsl -lgslcblas
Example of program compilation that uses GCC 11.3.0 and GSL v. 2.7:
module load GSL/2.7-GCC-11.3.0
gcc -O program.c -I${EBROOTGSL}/include -L${EBROOTGSL}/lib -lgsl -lgslcblas -Wl,-rpath=${EBROOTGSL}/lib
Users can include the compilation option e.g. -Wl,-rpath=${EBROOTGSL}/lib to include the library directory in the runtime path. If this option is not included, then at runtime the user has to load the GSL module again, in order to define the environment variable LD_LIBRARY_PATH.