Naming convention used for ParaMonte library builds

Across all supported Operating Systems (OS) and platforms/architectures, a universal naming convention is currently used to build the ParaMonte kernel libraries,

libparamonte_<interface language: c/cpp/fortran/matlab/python/r/...>_<OS: windows/linux/darwin/...>_<architecture: amd64/arm64/...>_<compiler vendor and major version: intel2021/gnu13/...>_<build type: native/tuned/ipo/release/testing/debug>_<library type: shared/static>_<memory allocation type: stack/heap>_<parallelism library/type: serial/mpi/impi/mpich/openmpi/openmp/cafsingle/cafshared/cafdist/...>_<runtime checking mode: checked/nocheck>.<library file extension: dll/lib/so/a/dylib>  

where,

  • interface language can be either:
    • c: indicating a library build meant to be called and used from C or C-complaint main applications.
    • cpp: indicating a library build meant to be called and used from C++ main applications.
    • fortran: indicating a library build meant to be called and used from Fortran main applications.
    • matlab: indicating a library build meant to be called and used from MATLAB main applications.
    • python: indicating a library build meant to be called and used from Python main applications.
    • r: indicating a library build meant to be called and used from R main applications.
  • operating system type can be either:
    • windows: indicating a library that can only be used on Windows OS, or,
    • darwin: indicating a library that can only be used on macOS, or,
    • linux: indicating a library that can only be used on Linux OS, or,
    • some other name (or unknown if it cannot be identified), indicating a library build meant to be used on the specific OS for which the library has been built.
  • architecture type can be either:
    • amd64: indicating a library built for the x86-64 architecture (also known as x64, x86_64, AMD64, and Intel 64), a 64-bit version of the x86 instruction set, first announced in 1999.
    • arm64: indicating a library that is built for arm64 architecture, also known as AArch64 or ARM64, a 64-bit extension of the ARM architecture family (M1, M2, M3 macOS chips).
    • Some other architecture (or unknown if it cannot be identified) indicates a library build that is meant to be used on the specific architecture for which the library has been built.
  • compiler suite can be any ParaMonte-compatible compiler vendor name you use to build the ParaMonte library. Currently, the ParaMonte build-scripts have only been tested with:
    • intel: on Windows and Linux OS for both serial and parallel ParaMonte library builds, as well as on Darwin (macOS) on amd64 chip, but only for serial ParaMonte library builds,
    • gnu: on Windows, Linux, and Darwin OS for both serial and parallel ParaMonte library builds.
  • build type can be either:
    • native: indicating a build targeting the current CPU architecture (leading to potentially non-portable binary), or,
    • tuned: indicating a build targeting a family of CPU architectures supported by the compiler (leading to potentially very large binary), or,
    • ipo: indicating an interprocedurally-optimized build targeting the current CPU architectures supported by the compiler, or,
    • release: indicating a build with compiler flags that ensure the fastest possible simulations at runtime while remaining broadly portable, or,
    • testing: indicating a build with compiler default optimization flags used only for testing purposes, or,
    • debug: indicating a build with compiler flags that enable tracing of any compile-time or run-time errors.
  • library type can be either:
    • shared: indicating a dynamically-linked ParaMonte library build, or,
    • static: indicating a statically-linked (archive) ParaMonte library build.
  • memory allocation type can be either:
    • stack: indicating static allocation of all automatic arrays and arrays created for temporary computations on the stack, or,
    • heap: indicating heap allocation of all automatic arrays and arrays created for temporary computations on the heap).
  • parallelism type can be either:
    • serial: indicating no parallelism, that is, a library built for serial simulations, or,
    • openmp: indicating a library built via the OpenMP standard for shared-memory (thread-based) parallelism, or,
    • mpi: indicating a library built via (some unknown brand) Message Passing Interface (MPI) that is meant to be linked against parallel main applications for parallel simulations via MPI, or,
    • impi: indicating a library built via the Intel Message Passing Interface (MPI) that is meant to be linked against parallel main applications for parallel simulations via Intel MPI, or,
    • mpich: indicating a library built via the MPICH Message Passing Interface (MPI) that is meant to be linked against parallel main applications for parallel simulations via MPICH MPI, or,
    • openmpi: indicating a library built via the OpenMPI Message Passing Interface (MPI) that is meant to be linked against parallel main applications for parallel simulations via OpenMPI, or,
    • cafsingle: indicating a library built via Coarray Fortran parallelism paradigm that is meant to be linked against Coarray parallel main applications optimized and usable for serial simulations only (i.e., no parallelization), or,
    • cafshared: indicating a library built via Coarray Fortran parallelism paradigm that is meant to be linked against Coarray parallel main applications for Coarray-enabled parallel simulations on shared-memory architecture, or,
    • cafdist: indicating a library built via Coarray Fortran parallelism paradigm that is meant to be used for Coarray-enabled parallel simulations on distributed-memory architecture, or,
  • runtime checking mode can be either:
    • checked: indicating all runtime memory-bound input argument sanity checks are enabled (which is useful for testing but can slow down the code), or,
    • nocheck: indicating all runtime memory-bound input argument sanity checks are disabled (which is the default behavior for production release code), or,

Supported platform and architecture

The ParaMonte library is currently developed with the presumption that it will be used on Windows/Linux/macOS operating systems (OS) built on an amd64 architecture system (also known as x64 on Windows and x86_64 on Linux and macOS). There is, however, no technical or programming barrier to building ParaMonte for other architectures as long as compatible MPI and Fortran/C compilers are available on the specific platform and architecture of interest.

Why are the prebuilt ParaMonte libraries available only for amd64 and arm64 architectures?

As of 2020, the amd64 and arm64 processor architectures takes the lion’s share of the market demand (illustrated in the figure below). It is costly for the ParaMonte developers (in terms of energy, money, and time) to build and release the library for all available architectures in the market. Note, however, that the library can be built on any architecture as long as a ParaMonte-compatible C/Fortran compiler can be installed on the system.

An illustration of the dynamics of the market share for different families of microprocessors in the TOP500 supercomputer ranking list, from 1992 to 2019.

How can I find out the platform and architecture of my system?

  • On Windows OS, open a Windows command-line interface (cmd.exe).
    • To find out your system’s OS, type,
      echo %OS%
      

      which should result in an answer like the following,

      Windows_NT
      
    • To check your system’s platform/architecture, type,
      echo %PLATFORM%
      

      which should result in an answer like the following,

      x64
      

      or,

      echo %PROCESSOR_ARCHITECTURE%
      

      which should result in an answer like the following,

      AMD64
      

      if your system’s architecture is amd64.


  • On Unix-like OS (Linux/macOS), open a Bash shell.
    • To find out your system’s OS, type,
      uname -s
      

      which should result in an answer like the following,

      Linux
      

      or,

      Darwin
      

      depending on the type of your OS.

    • To check your system’s platform/architecture, type,
      uname -m
      

      which should result in an answer like the following,

      x86_64
      

      if your system’s architecture is amd64.


If you have any questions about the topics discussed on this page, feel free to ask in the comment section below, or raise an issue on the GitHub page of the library, or reach out to the ParaMonte library authors.