You are located in service: RWTH High Performance Computing (Linux)

Module System

Module System

Kurzinformation

 

Table of Contents

  1. Basics
    1. Loading and unloading modules
    2. Searching modules
    3. Personal module collections
  2. Example
  3. Core compiler
  4. Toolchains
    1. Existing Toolchains
      1. Intel-based
      2. GCC-based
  5. External documentation

Detailinformation

Basics

 

The RWTH-HPC system uses a module software called Lmod. Modules allow you to access installed software using a simple syntax. We offer a variety of software packages, ranging from simulation suites and performance tools to common software libraries. Many of these are offered in multiple versions. The module command allows you to load new software into your current environment without the need to configure them manually. 

The different modules are grouped into a module hierarchy based on the compiler and possibly the MPI implementation on which they depend. As a consequence, modules can only be loaded when the compiler and MPI they depend on have already been loaded. The purpose of this mechanism is to prevent you from loading incompatible software that would crash on startup or when accessing a certain feature. Some modules, e.g., MATLAB, do not depend on any compiler and can thus be loaded at any time. Other software may depend only on a certain compiler and require no MPI implementation and other modules may have a very strict set of dependencies. We advise browsing around the module system for a bit to familiarize yourself with its concepts.

Loading and unloading modules

Please Note: You can use ml as a shorthand for module.

Lmod uses a hierarchical module scheme in which not all modules are visible at any given time. You can list the module currently available with the avail option.

module avail

You can load a module with the load option.

module load foo

Please Note: If no version is specified, the default version is automatically chosen. If only a single version is available of a certain module, then this will automatically become the default. Default versions of modules are marked with (D) in the list of available modules.

When loading a module, the module system may set module-specific variables in the environment. This may influence the PATH and LD_LIBRARY_PATH, influencing executables and libraries visible to the user. You may also be notified that other modules are loaded automatically as a dependency. To remove any modifications to the environment by a specific module, you can unload specific modules with the unload option.

module unload foo

Sometimes you may want to unload all current modules and start with a "fresh" environment. In this case you can use

module purge

To get a list of all loaded modules, you can use the list option.

module list

To check which environment changes a certain module would cause upon loading, you can use the show option

module show foo
module show foo/1.2.3

Please Note: The output will only list the dependent load operations for a specific package. If one of those packages is already loaded it will be omitted in the output.

Searching modules

From the old TCL module system you are used to having categories, like DEVELOP, CHEMISTRY etc. pp. So if you are looking for chemistry software, you would load the CHEMISTRY module and see what software is installed. This is what is called a "Categorized Module Naming Scheme" or CMNS for short.

With Lmod, this has changed to a Hierarchical Module Naming Scheme (HMNS), which loads additional module paths whenever a module is loaded that was used to build software (e.g., Open MPI only becomes visible once you have loaded the compiler that was used to build that version of Open MPI). This is in contrast to CMNS. To enable category-based searching for modules in an HMNS, we added the category subcommand to Lmod:

$ module category

To get a list of every module in a category execute:
   $ module category Foo
      
------------------------------ List of Categories ------------------------------
cfd  chem  devel  io  material  math  perf  tools

which shows you the categories which are agreed with the colleagues of the TU Darmstadt. Which software is hidden behind the categories can be seen by entering (e.g. for chemistry) the following:

$ module category chem

To learn more about a package and how to load it execute:
   $ module spider Bar
      
------------------------------------- chem -------------------------------------
Gaussian (6)   PETSc (1)   QuantumESPRESSO (1)   VASP (2)

If you don't know how a specific module is called or a module is currently not visible to you and you want to search for a software, you can use the spider subcommand.

$ module spider foo

Please Note: Searching for a module with spider is case in-sensitive and also returns partial matches (the search argument is part of an existing module). Further note that spider searches in the module name and the description.

When called only with the module name and no specific version, the output of spider lists all available versions across all toolchains. When called with a specific version, the output lists toolchains that will make it available.

$ module spider foo/1.2.3

To unload a module and load a module with one call, you can use the switch option.

$ module switch foo bar
Please Note: Lmod automatically unloads conflicting modules and inactivates modules that are no longer available.

If you want to reset the module environment to the system default, you can use the reset option.

$ module reset

Personal module collections

You can save a collection of loaded modules to a named collection with the save option.

$ module save <collection-name>

To restore a previously saved collection, you can restore the saved module collection with the restore option.

$ module restore <collection-name>

To list all available personal module collections, you can use the savelist option.

$ module savelist

To remove a specific saved module collection.

$ module disable <collection-name>

Example

Assume you want to know whether a package is available on the cluster, in this example LAMMPS.

  1. First check by using spider for a case-insensitive, partial-match search for the package.

    $ module spider LAMMPS
    
    ----------------------------------------------------------------------------
      LAMMPS:
    ----------------------------------------------------------------------------
        Description:
          LAMMPS is a classical molecular dynamics code, and an acronym for
          Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
          potentials for solid-state materials (metals, semiconductors) and
          soft matter (biomolecules, polymers) and coarse-grained or mesoscopic
          systems. It can be used to model atoms or, more generically, as a
          parallel particle simulator at the atomic, meso, or continuum scale.
          LAMMPS runs on single processors or in parallel using message-passing
          techniques and a spatial-decomposition of the simulation domain. The
          code is designed to be easy to modify or extend with new
          functionality. 
    
         Versions:
            LAMMPS/3Mar2020-Python-3.8.2-kokkos
            LAMMPS/23Jun2022-kokkos
    
    ----------------------------------------------------------------------------
      For detailed information about a specific "LAMMPS" package (including how to load the modules) use the module's full name.
      Note that names that have a trailing (E) are extensions provided by other modules.
      For example:
    
         $ module spider LAMMPS/23Jun2022-kokkos
    ----------------------------------------------------------------------------
    
    
  2. As shown on the last line (for the default module of that name), specifying a specific version explicitly, will list the dependencies needed to be loaded before the respective module becomes available.
    $ module spider LAMMPS/23Jun2022-kokkos
    
    ----------------------------------------------------------------------------
      LAMMPS: LAMMPS/23Jun2022-kokkos
    ----------------------------------------------------------------------------
        Description:
          LAMMPS is a classical molecular dynamics code, and an acronym for
          Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
          potentials for solid-state materials (metals, semiconductors) and
          soft matter (biomolecules, polymers) and coarse-grained or mesoscopic
          systems. It can be used to model atoms or, more generically, as a
          parallel particle simulator at the atomic, meso, or continuum scale.
          LAMMPS runs on single processors or in parallel using message-passing
          techniques and a spatial-decomposition of the simulation domain. The
          code is designed to be easy to modify or extend with new
          functionality. 
    
    
        You will need to load all module(s) on any one of the lines below before the "LAMMPS/23Jun2022-kokkos" module is available to load.
    
          GCC/10.3.0  OpenMPI/4.1.1
     
        Help:
          Description
          ===========
          LAMMPS is a classical molecular dynamics code, and an acronym
          for Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
          potentials for solid-state materials (metals, semiconductors) and soft matter
          (biomolecules, polymers) and coarse-grained or mesoscopic systems. It can be
          used to model atoms or, more generically, as a parallel particle simulator at
          the atomic, meso, or continuum scale. LAMMPS runs on single processors or in
          parallel using message-passing techniques and a spatial-decomposition of the
          simulation domain. The code is designed to be easy to modify or extend with new
          functionality.
          
          
          More information
          ================
           - Homepage: https://www.lammps.org
    
    

Listed above the "Help:" line are dependencies to make that specific version available. If the package is available for different compiler and MPI combinations (or other dependencies), Lmod will list multiple lines here where each separate line lists all dependencies for that toolchain. In this example loading the corresponding GCC and OpenMPI package will work.

$ module load GCC/10.3.0 OpenMPI/4.1.1 LAMMPS/23Jun2022-kokkos

Please Note: Even though Lmod allows to automatically unload modules of conflicting packages, such families are NOT defined on CLAIX, to explicitly allow for loading multiple compilers into the environment.

Core Compiler

For all packages a certain version of GCC is automatically loaded as GCCcore module. The GCCcore module will be part of the dependencies for making a certain module visible.

Toolchains

Toolchains are so-called meta modules that load a specific Compiler and MPI combination (and in some cases some additional libraries).

Existing Toolchains

Intel-based

ToolchainCompilerCore CompilerMPIOthers
intel/2019biccifort/2019.5.281GCCcore/.8.3.0impi/2021.6.0imkl/2019.5.281
intel/2020aiccifort/2020.1.217GCCcore/.9.3.0impi/2021.6.0imkl/2020.1.217
intel/2020biccifort/2020.4.304GCCcore/.10.2.0impi/2021.6.0imkl/2020.4.304
intel/2021aiccifort/2020.1.217GCCcore/.10.3.0impi/2021.6.0imkl/2020.1.217
intel/2021bintel-compilers/2021.4.0GCCcore/.11.2.0impi/2021.6.0imkl/2021.4.0 imkl-FFTW/2021.4.0
intel/2022aintel-compilers/2022.1.0GCCcore/.11.3.0impi/2021.6.0imkl/2022.1.0 imkl-FFTW/2022.1.0
iimpi/2019biccifort/2019.5.281GCCcore/.8.3.0impi/2021.6.0 
iimpi/2020aiccifort/2020.1.217GCCcore/.9.3.0impi/2021.6.0 
iimpi/2020biccifort/2020.4.304GCCcore/.10.2.0impi/2021.6.0 
iimpi/2021aiccifort/2020.1.217GCCcore/.10.3.0impi/2021.6.0 
iimpi/2021bintel-compilers/2021.4.0GCCcore/.11.2.0impi/2021.6.0 
iimpi/2022aintel-compilers/2022.1.0GCCcore/.11.3.0impi/2021.6.0 
iompi/2020aiccifort/2020.1.217GCCcore/.9.3.0OpenMPI/4.0.3 
iompi/2020biccifort/2020.4.304GCCcore/.10.2.0OpenMPI/4.0.5 
iompi/2021aintel-compilers/2021.2.0GCCcore/.10.3.0OpenMPI/4.1.1 
iomkl/2020aiccifort/2020.1.217GCCcore/.9.3.0OpenMPI/4.0.3imkl/2020.1.217
iomkl/2020biccifort/2020.4.304GCCcore/.10.2.0OpenMPI/4.0.5imkl/2020.4.304
iomkl/2021aintel-compilers/2021.2.0GCCcore/.10.3.0OpenMPI/4.1.1imkl/2021.2.0

GCC-based

ToolchainCompilerMPIOthers
foss/2020aGCC/9.3.0OpenMPI/4.0.3OpenBLAS/0.3.9 FFTW/3.3.8 ScaLAPACK/2.1.0
foss/2021aGCC/10.3.0OpenMPI/4.1.1FlexiBLAS/3.0.4 FFTW/3.3.9 ScaLAPACK/2.1.0-fb
foss/2021bGCC/11.2.0OpenMPI/4.1.1FlexiBLAS/3.0.4 FFTW/3.3.10 ScaLAPACK/2.1.0-fb
foss/2022aGCC/11.3.0OpenMPI/4.1.4FlexiBLAS/3.2.0 FFTW/3.3.10 FFTW.MPI/3.3.10 ScaLAPACK/2.2.0-fb
gompi/2020aGCC/9.3.0OpenMPI/4.0.3 
gompi/2020bGCC/10.2.0OpenMPI/4.0.5 
gompi/2021aGCC/10.3.0OpenMPI/4.1.1 
gompi/2021bGCC/11.2.0OpenMPI/4.1.1 
gompi/2022aGCC/11.3.0OpenMPI/4.1.4 
gomkl/2020aGCC/9.3.0OpenMPI/4.0.3imkl/2020.1.217
gomkl/2020bGCC/10.2.0OpenMPI/4.0.5imkl/2020.4.304
gomkl/2021aGCC/10.3.0OpenMPI/4.1.1imkl/2021.2.0
gcccuda/2019aGCC/8.3.0 CUDA/10.1.243

  Zusatzinformation

External Documentation

last changed on 11/15/2023

How did this content help you?

Creative Commons Lizenzvertrag
This work is licensed under a Creative Commons Attribution - Share Alike 3.0 Germany License