The AMD Optimizing C/C++ and Fortran Compiler (AOCC) is highly optimized for x86 targets, especially for AMD Zen architecture-based processors.

AOCC leverages LLVM, a project that includes a collection of modular and reusable compiler and toolchain technologies. With LLVM, converting a source code to a machine code (object code) for a specific processor involves three phases:

Frontend phase

In this phase, the frontend parses, validates, and diagnoses errors in the source code, and converts the parsed code into the LLVM language-independent intermediate representation (LLVM IR)
One option that can be used as a C/C++ language compiler frontend is Clang, which is a project under the LLVM umbrella. Similarly, Flang is a Fortran language frontend integrated with LLVM.

Optimizer phase

The IR is transformed into an optimized IR by going through a series of optimization passes (e.g., inlining, unrolling, dead code elimination, and so on.)

Backend phase

The optimized IR is transformed into a target-specific machine code.

AOCC is a proprietary fork of LLVM+Clang, with changes to improve performance for processors based on the AMD Zen microarchitectures. For example, AOCC version 4.2 is based on LLVM version 16.0.3.

AOCC 4.2 supports the following standards:

• C: C17 (default), C11, C99.
• C++: C++20, C++17 (default), C++14, C++11, C++98.
• Fortran: Fortran-95, Fortran-2003, partial support of Fortran-2008.
• OpenMP:
  • For C and C++: OpenMP 5.0 and earlier standards.
  • For Fortran: OpenMP 4.5.

AOCC Usage

Multiple versions of AOCC are installed on NAS systems. We recommend using the latest version.

Load an AOCC Modulefile

After one of the modules is loaded, the environment variables PATH, LIBRARY_PATH, LD_LIBRARY_PATH, C_INCLUDE_PATH, and CPLUS_INCLUDE_PATH are modified.

You can load an AOCC modulefile as follows:

% module use -a /nasa/modulefiles/testing
% module avail comp-aocc
--- /nasa/modulefiles/toss4 ---
comp-aocc/3.2.0
--- /nasa/modulefiles/testing ---
comp-aocc/4.0.0  comp-aocc/4.1.0  comp-aocc/4.2.0
% module load comp-aocc/4.2.0

Compile and Link using the Clang, Clang++, or Flang Compiler Driver

Use one of the following command lines:

clang   [command-line options] program.c
clang++ [command-line options] program.cpp
flang   [command-line options] program.f90

A few command-line options are provided here:

• -O3: provides more optimization than the -O3 in the base LLVM version.
  Note:  -O2 is the default in AOCC 4.2.
• -Ofast: -O3 plus other aggressive optimizations that may violate strict compliance with language standards.
  Note: -Ofast in AOCC has more optimization than -Ofast in the base LLVM version.
• -march=znver3: generates instructions that target AMD Zen 3 processor (such as Milan).
• -ffast-math: enables faster but less-precise math operations.
• -ffp-model={precise,fast}: is only applicable to Flang; "precise" disables optimizations that are not value-safe on floating-point data.
• -fopenmp: parses OpenMP programs/directives and generates parallel code.
• -flto: provides whole program analysis with Link Time Optimization (LTO).
• -fuse-ld=lld: uses the LLD linker (default).
• -fgen-aor: generates compiler-time AOCC optimization report (AOR); for link-time AOR generation, add -flto -fuse-ld=lld.
  Note: The generation of AOR requires python3. With AOCC 4.2, the script run_opt-viewer that is used to generate the report requires python3.8.

You can find a list of command-line options on the Clang help page (clang --help) or in Chapter 5: Command-line Options in the AMD AOCC User Guide. Additional options can be found in Compiler Options Quick Reference Guide for Zen 3 and Zen 4 processors.

Link to an AMD AOCL Library

Some applications might perform better on the AMD Zen processors when they use AOCL, rather than using other scientific and math libraries from other sources. For more information, see AMD Optimizing CPU Libraries (AOCL).

Link to an MPI Library

HPE MPT

HPE MPT provides the wrapper scripts mpicc, mpicxx, and mpif90 for compiling and linking MPI applications. Each of the scripts detects which compilers are available in your environment, and uses the first one it finds when checking against a list of compilers included in the script.

With the module mpi-hpe/mpt.2.2825Apr23_rhe187, the list of precedence for the mpif90 script is {ifort openf90 pgf90 pgf95 lf95 gfortran}. For mpicc and mpicxx scripts, the only choice in the list is gcc and g++.

In order to use an AOCC compiler with these wrapper scripts, you must set some environment variables, as shown below. You can use the option -show of these wrapper scripts to find out which compiler is chosen.

% module use -a /nasa/modulefiles/testing
% module load comp-aocc/4.2.0
% module load mpi-hpe/mpt

• C code

  % export MPICC_CC=clang
  % mpicc -show
  clang -I/nasa/hpe/mpt/..../include -lpthreads -L/nasa/hpe/mpt/... -lmpi
  % mpicc [options] program.c

• C++ code

  % export MPICXX_CXX=clang++
  % mpicxx -show
  clang++ -I/nasa/hpe/mpt/..../include -lpthreads -L/nasa/hpe/mpt/... -lmpi
  % mpicxx [options] program.cc

• Fortran code

  % export MPIF90_F90=flang
  % mpif90 -show
  flang -I/nasa/hpe/mpt/..../include -lpthreads -L/nasa/hpe/mpt/... -lmpi
  % mpif90 [options] program.f

OpenMPI

OpenMPI provides the wrapper compilers mpicc, mpic++ (or mpicxx, mpiCC), and mpifort for compiling and linking MPI applications. The legacy wrappers mpif77 and mpif90 still exist, but are symbolic links to mpifort. The compilers used by these wrappers default to the compilers used to build the OpenMPI library. After loading an OpenMPI module, you can run one of these commands to find the compilers used: ompi_info, mpicc --showme, mpic++ --showme, or mpifort --showme .

When building your application with an AOCC compiler and an OpenMPI library, the OpenMPI library that you use should be one that is also built with the AOCC compiler. This is especially true if your application is written in Fortran.

For applications written in C, you may be able to compile with an AOCC compiler and link with an OpenMPI library built with a different compiler, as shown below:

% module use -a /nasa/modulefiles/testing
% module load comp-aocc/4.2.0
% module load openmpi/4.1.6-toss4-gnu

% export OMPI_CC=clang
% mpicc --showme
clang -I/nasa/openmpi/4.1.6-gnu/include -pthread -L/nasa/openmpi/4.1.6-gnu/lib -Wl,
       -rpath -Wl,/nasa/openmpi/4.1.6-gnu/lib -Wl,--enable-new-dtags -lmpi
% mpicc [options] program.c

References

• The Architecture of Open Source Applications (Volume 1) LLVM
• AMD Optimizing C/C++ and Fortran Compilers (AOCC)
• AMD AOCC User Guide
• AMD EPYC 9xx4-series Processors Compiler Options Quick Reference Guide
• AMD EPYC 7xx3-series Processors Compiler Option Quick Reference Guide