Code Compilation on Sapelo2

From Research Computing Center Wiki
Jump to navigation Jump to search


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.

Back to Top

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:

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


Back to Top

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.

Back to Top

Retrieved from "https://wiki.gacrc.uga.edu/index.php?title=Code_Compilation_on_Sapelo2&oldid=21461"