Anaconda Python by default auto-activates the “base” environment each time a new Terminal is opened. This slows opening new Terminals, particularly on systems with slow or virtual disks. Particularly if the user isn’t constantly using Python, it can be beneficial to make conda only active when specified. To disable conda auto-activation on new Terminals, type:
conda config --set auto_activate_base false
Fortran compilers typically have options for enforcing Fortran standards.
The compilers raise additional warnings or errors for code that is not deemed compliant.
Fortran standard options can make false warnings, so we generally do not enable standards checking for user defaults.
However, we do enforce implicit none as a quality measure.
It’s also important to use implicit none so that each variable must be assigned beforehand.
We recommend the Fortran 2018 statement:
implicit none (type, external)
which requires explicitly defined procedure interfaces as well.
typeimplicit none defaultexternalGCC Gfortran -std=f2018 enforces Fortran 2018 standard. Consider these Gfortran options:
gfortran -Wall -fimplicit-none
Intel oneAPI
-stand f18
enforces Fortran 2018 standard.
Consider these
options
that also enforce implicit none:
ifx -warn
Cray Fortran compiler enforces implicit none via
option:
ftn -eI
note that’s a capital “I” not a lowercase “ell”.
Nvidia HPC Fortran compiler enforces implicit none via:
nvfortran -Mdclchk
NAG Fortran has
-f2018
Fortran 2018 flag.
Enforce implicit none by:
nagfor -u
CMake logic to enforce these standards:
if(CMAKE_Fortran_COMPILER_ID STREQUAL Cray)
add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-eI>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL GNU)
add_compile_options(-Wall "$<$<COMPILE_LANGUAGE:Fortran>:-fimplicit-none>")
elseif(CMAKE_Fortran_COMPILER_ID MATCHES "^Intel")
add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-warn>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL NVHPC)
add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-Mdclchk>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL NAG)
add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-u>")
endif()
Major projects with CPU arch-specific code take a while to implement new CPU architectures. Apple Silicon (M1, etc.) are a key example. For example, Anaconda Python has Intel and Apple Silicon installers. Check if a C++, GNU Octave, Matlab, or Python executable on Apple Silicon is using native or Rosetta:
Reference: Apple sysctl
GCC Gfortran and Intel oneAPI are the most advanced, widely available modern Fortran compilers.
Useful Fortran 2018 enhancements include:
select rank
assumed array rank,
error stop
within pure procedures,
random_init
to initialize random number seed, and
implicit none (type, external)
to require external procedures to be explicitly declared.
GCC 9 is the
oldest version
currently maintained.
Intel oneAPI has full Fortran 2018
support.
To get recent GCC is usually straightforward. Red Hat should use GCC Toolset. MacOS Homebrew quickly adds the latest GCC version. If Ubuntu gfortran repo defaults aren’t adequate, get recent Gfortran via PPA.
Here are some of the major changes in Gfortran by version:
select rankrandom_init() to initialize the random generator seed…randomlydo concurrent, actual argument array with too few elements for dummy argument now errors, initial support for parameterized derived types (simply define kind at initialization) and coarray support for teams. Standard flag -std=f2018 added and deprecated -std=f2008ts.select type. Complete Fortran 2003 support, Fortran 2018 non-constant stop and error stop codes, and -fdec- options to help compile very old non-standard code.Gfortran 6 added Fortran 2008 submodule support, useful for large projects to save compilation time and allow powerful use scenarios.
Fortran 2003 deferred-length character are
useful
for avoiding bothersome trim() everywhere.
GCC 5 added full support for OpenMP 4.0, Fortran 2003 ieee_ intrinsics, Fortran 2008 error stop in pure procedures with constant error code.
GCC 4.9 added Fortran 2003 deferred-length character variables in derived types.
GCC 4.8 supported Fortran 2008 polymorphism, including select type, class(*), type(*), and assumed rank dimension(..).
GCC 4.6 was the first version of Gfortran reaching beyond Fortran 95, with Fortran 2003 deferred-length character variable and Fortran 2008 impure elemental support.
GCC 4.5 added Fortran 2008 iso_fortran_env.
GCC 4.4 added initial support for polymorphism and OpenMP 3.
CMake allows switching parameters based on compiler version. This is very useful for modern Fortran programs.
Example CMakeLists.txt for Fortran compiler version dependent options.
if(CMAKE_Fortran_COMPILER_ID STREQUAL GNU)
add_compile_options(
-Wall
$<$<COMPILE_LANGUAGE:Fortran>:-fimplicit-none>
)
endif()
add_executable(myprog main.f90)
Reference: Gfortran changelog
Matlab has worked on Apple Silicon via Rosetta since Matlab R2020b. Matlab R2022a Apple Silicon beta foreshadows an upcoming Matlab release that runs natively on Apple Silicon. We have provided a Matlab script that detects if Matlab is running using Rosetta.
CMake can detect the host CPU arch to use with Intel compilers. We discourage package maintainers from settings flags like “-march=native” (GCC, Clang) and “-xHost” (Intel oneAPI) because they may break on user systems such as ARM or HPC. However, the user can set flags for a project by setting environment variables like CFLAGS before the first project configure in CMake. This allows optimizing for a target compiler while compiling from a different host. Or, the user on an appropriate system may simply set their ~/.profile to have CFLAG=-march=native or similar.
Projects use a variety of methods to detect which compiler is being used to thereby set compilation options. Although this discussion focuses on Fortran, it is easily and equally applicable to other languages such as C and C++.
Robustly detect compiler in CMake CMAKE_Fortran_COMPILER_ID. This tells the compiler vendor (GNU, Intel, Clang, etc.) Don’t use CMAKE_Fortran_COMPILER because there are several compiler executables per vendor and this will not be robust over time. To get the compiler version, CMAKE_Fortran_COMPILER_VERSION allows version comparisons.
Example:
if(CMAKE_Fortran_COMPILER_ID MATCHES "^Intel")
add_compile_options("$<$<COMPILE_LANGUAGE:Fortran>:-check;-warn;-traceback>")
elseif(CMAKE_Fortran_COMPILER_ID STREQUAL GNU)
# Gfortran
add_compile_options(-Wall -Werror=array-bounds -Wextra -Wpedantic)
endif()
On Windows, C++ programs that use _CrtDumpMemoryLeaks should have the appropriate include statement to work on Windows with non-Visual Studio compilers such as GCC. Example:
#ifdef _WIN32
#include <crtdbg.h>
#endif
// near the end of the function to be checked
#ifdef _WIN32
_CrtDumpMemoryLeaks();
#endif
[_set_printf_count_output}(https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-printf-count-output) is a Visual-Studio only function. Therefore, C++ programs that call it should use a preprocessor conditional:
#ifdef _MSC_VER
_set_printf_count_output();
#endif
Windows C++ programs using POSIX write or read should have a preprocessor include io.h like:
#ifdef _WIN32
#include <io.h>
#endif