Scientific Computing

Fortran 2018 contiguous arrays are discussed in pp.139-145 of “Modern Fortran Explained: Incorporating Fortran 2018”. In general, operating on contiguous arrays is faster than non-contiguous arrays.

Contiguous variables happen by default, so unless using pointers or array striding, the variable is likely to be contiguous for simple Fortran code. Check contiguous status of a variable with is_contiguous intrinsic function.

A non-contiguous array actual argument into a contiguous subroutine dummy argument is made contiguous by copy-in, copy-out. This copy-in copy-out as needed is part of the Fortran 2008 and Fortran 2018 standard. GCC ≥ 9, Intel oneAPI, LLVM Flang, etc. work to Fortran 2008+ standard for contiguous dummy argument copy-in, copy-out for non-contiguous actual argument.

References: Fortran CONTIGUOUS

CMake can use clang-tidy as a build option for a CMake project by adding a few parameters to CMakeLists.txt. It’s also possible to use clang-tidy without modifying CMakeLists.txt. Generate the file compile_commands.json used by clang-tidy. You don’t have to build the project as we are interested in checking and possibly fixing the C++ source code.

To install clang-tidy in macOS:

brew install llvm

edit file ~/.zshrc, adding the line

alias clang-tidy=$(brew --prefix llvm)/bin/clang-tidy

To install clang-tidy in Linux:

apt install clang-tidy

cmake -Bbuild -DCMAKE_EXPORT_COMPILE_COMMANDS=on

Run clang-tidy. Specify options or use a file .clang-tidy, which is usually in the top directory of the project.

clang-tidy -p build/ <glob or files>

To fix the errors, add clang-tidy option --fix.

CMake doesn’t have a “sleep” command, but sleep in floating point seconds is accomplished by:

execute_process(COMMAND ${CMAKE_COMMAND} -E sleep 0.5)

This uses CMake command tool to sleep in a platform-indpeendent manner.

cmake -E sleep 0.5

The minimum practical time is about 0.1 seconds. Below that, the overhead of starting/stopping CMake starts to dominate elapsed time.

CMake can output JSON in google-trace format that can help understand what tasks a CMake project configuration is taking time on.

cmake -B build --profiling-output=perf.json --profiling-format=google-trace

View profiler data: type in web browser (Chrome or Edge) address bar “about:tracing” and Load “perf.json”.

Other google-trace viewers can also be used.

For example, in a minimal C++ project on a Windows computer:

cmake_minimum_required(VERSION 3.18)
project(b LANGUAGES CXX)

Approximate percent of CMake configure time spent:

• system ID: 1%
• Generator identify: 2%
• Compiler identification: 50%
• Compiler capabilities: 47%

A project switched to Fortran mpi_f08 after realizing runtime crashes in very large simulations were due to MPI-2. The Fortran mpi_f08 interface was released in 2012 and is well supported by contemporary compilers and MPI libraries. MPICH reqiures ISO_Fortran_binding.h. GCC + MPICH or Clang + OpenMPI and many other combinations work.

CMake can retrieve the current time in local (default), UTC, or other timezone via string(TIMESTAMP). Elapsed time can also readily be computed or compared using timestamp format %s

Currently, CMake math command cannot handle floating point numbers, only integers.

string(TIMESTAMP t)
message(STATUS "local time: ${t}")

string(TIMESTAMP t0 "%s")
execute_process(COMMAND ${CMAKE_COMMAND} -E sleep 1.0)
string(TIMESTAMP t1 "%s")

math(EXPR elapsed "${t1} - ${t0}")

message(STATUS "Elapsed time: ${elapsed} seconds")

Git history browsing can be easier with a GUI, which are available for most platforms. Git installs can come with a GUI by default. However, many package managers make the GUI a separate install to save considerable time and space on cloud servers, virtual machines and similar. Here are a few example commands to install gitk, a basic Git history browser:

• macOS: brew install git-gui
• Linux: apt install gitk or dnf install gitk or similar
• Windows: winget install Git.Git that comes with “gitk”

For those using GitHub, GitHub Desktop is a popular Git GUI.

The GitHub Actions CI runners have a recent release of CMake and update regularly, often within weeks of a new CMake release. There are Actions in the GitHub Marketplace allowing one to pick specific CMake versions for testing the build system if desired. CMake environment variables are handy to set in top level “env” to avoid forgetting to specify them.

Note that Windows compiler tests in general, including CMake, are often done with distinct setups. These are best shown by example using MSYS2 or MSVC.

name: ci

env:
  CTEST_NO_TESTS_ACTION: error
  CTEST_PARALLEL_LEVEL: 0
  HOMEBREW_NO_INSTALL_CLEANUP: 1
  CMAKE_GENERATOR: Ninja

on:
  push:
    paths:
      - "**.c"
      - "**.cpp"
      - "**.h"
      - "**/CMakeLists.txt"
      - "**.cmake"
      - ".github/workflows/ci.yml"

jobs:

  core:

    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest]
        shared: [true, false]

    runs-on: ${{ matrix.os }}

    steps:

   - uses: actions/checkout

    - name: config shared=${{ matrix.shared }}
      run: >-
        cmake
        -Bbuild
        -DBUILD_SHARED_LIBS=${{ matrix.shared }}

    - name: build
      run: cmake --build build

    - name: test
      run: ctest --test-dir build -V

Programs across programming languages can make system calls. System calls can be a significant security concern. For example, allowing unsanitized user input is an obvious hazard.

A modern method of making system calls in C and C++ across operating systems is exec, known on Windows as _exec.

An execlp example demonstrates casting intptr_t to int for the specific cases where a function is known to use intptr_t in this way.

The Fortran 2003 standard ieee_arithmetic intrinsic module gives a robust standard way to use NaN and other functions. However, on certain CPU arches such as PPC, GCC does not yet support ieee_arithmetic.

An example of robust NaN is given in nans.f90. A Fortran standard way to make NaN constant is:

use, intrinsic :: ieee_arithmetic, only: ieee_value, ieee_quiet_nan
implicit none

real:: nan

nan = ieee_value(0., ieee_quiet_nan)

Example NaN memory hex value–can be distinct on older/other compilers:

GCC 12.2.0; Intel oneAPI 2021, 2023
      IEEE   value   isnan                         hex
    real 32    NaN      T                          7FC00000
    real 64    NaN      T                  7FF8000000000000
    real128    NaN      T  7FFF8000000000000000000000000000
 complex 64    NaN      T                          7FC00000
 complex128    NaN      T                  7FF8000000000000
 complex256    NaN      T  7FFF8000000000000000000000000000

nvfortran 22.11 is same for real32/64