Page tree
Skip to end of metadata
Go to start of metadata



Introduction

This section contains details about the user application environment and how it can be controlled via the module command

Module structure

Modules are organised by categories such as applications, compilers and libraries, with a number of applications and software packages in each category. 

Available module classes


base

Default module class

bio

Bioinformatics, biology and biomedical

cae

Computer Aided Engineering (incl. CFD)

chem

Chemistry, Computational Chemistry and Quantum Chemistry

compilerCompilers
data

Data management & processing tools

debuggerDebuggers
devel

Development tools

geoEarth Sciences
ide

Integrated Development Environments (e.g. editors)

lang

Languages and programming aids

lib

General purpose libraries

math

High-level mathematical software

mpiMPI stacks
numlib

Numerical Libraries

perf

Performance tools

phys

Physics and physical systems simulations

system

System utilities (e.g. highly depending on system OS and hardware)

toolchain

EasyBuild toolchains

tools

General purpose tools

vis

Visualization, plotting, documentation and typesetting


Working with modules

The name of each module is composed of three parts: i) the module class, ii) the name of the application, ii) the application version number and compiler toolchain used to build the application. For example the module name:

lang/Python/3.7.0-foss-2018b

refers to version 3.7.0 of the Python language interpreter, which has been built using version 2018b of the foss compiler toolchain.

This structure of modules allows us to support many permutations of application versions, built with different compiler versions and technologies. We can thus support new application versions, or optimised builds, without disruption to users who still require earlier editions.

Toolchains

EasyBuild employs so-called compiler toolchains or, toolchains for short, which are a major concept in handling the application build and installation processes.

A typical toolchain consists of one or more compilers (gcc, icc), usually coupled with a number of libraries for specific functionality (e.g., an MPI stack for distributed computing), or optimised routines for commonly used math operations (e.g., the well-known BLAS/LAPACK APIs for linear algebra routines).

The majority of software available on Viking uses one of two common toolchains, foss and intel:

toolchaindescription
foss

The foss common compiler toolchain consists entirely of open source software (hence the name, derived from the common term ‘FOSS’, which is short for “Free and Open Source Software”).

This toolchain consists of:

intel

The intel common compiler toolchain consists of the Intel compilers and libraries, i.e.:


module avail

Use the command module avail to list available modules.

List available modules

$ module avail

---------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/bio ----------
ABySS/2.0.2-foss-2018b ABySS/2.1.0-foss-2018b (D)

------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/compiler --------
GCC/8.1.0-2.30 GCCcore/8.1.0

--------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/data ----------
HDF5/1.8.20-foss-2018b

--------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/devel ---------
Autoconf/2.69-foss-2018b M4/1.4.17
Autoconf/2.69-GCCcore-8.1.0 (D) M4/1.4.18-GCCcore-8.1.0
Automake/1.15-foss-2018b M4/1.4.18 (D)
Automake/1.16.1-GCCcore-8.1.0 (D) SQLite/3.24.0-GCCcore-8.1.0
Autotools/20150215-foss-2018b ncurses/6.0-foss-2018b
Autotools/20180311-GCCcore-8.1.0 (D) ncurses/6.0
Boost/1.66.0-foss-2018b ncurses/6.1-GCCcore-8.1.0 (D)
M4/1.4.17-foss-2018b sparsehash/2.0.3-foss-2018b

--------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/lang ----------
Bison/3.0.4-GCCcore-8.1.0 flex/2.6.0
Bison/3.0.4 (D) flex/2.6.3-GCCcore-8.1.0
Python/2.7.15-foss-2018b flex/2.6.3
Python/3.6.1-foss-2018b flex/2.6.4-GCCcore-8.1.0
Python/3.7.0-foss-2018b (D) flex/2.6.4 (D)
Tcl/8.6.8-GCCcore-8.1.0

In the above example, we have two versions of the application ABySS (2.0.2, 2.1.0) built with the same foss toolchain.

The following example lists the available versions of Bison.

List available application versions
$ module avail Bison

------------ /usr/local/pkg/EasyBuild/config-files-york/modules/all ------------
   lang/Bison/3.0.4-GCCcore-8.1.0    lang/Bison/3.0.4 (D)

--------- /usr/local/pkg/EasyBuild/config-files-york/modules/all/lang ----------
   Bison/3.0.4-GCCcore-8.1.0    Bison/3.0.4 (D)

  Where:
   D:  Default Module

Use "module spider" to find all possible modules.
Use "module keyword key1 key2 ..." to search for all possible modules matching
any of the "keys".

There are two versions of Bison in the lang module class which can be loaded. The default one (marked by '(D)') is the one built with the default toolchain. The other is built with version 8.1.0 of the GCC compiler suite.

module spider <module>

The module spider string command allows you to search for modules matching the string.

Search for modules
$ module spider bison

----------------------------------------------------------------------------
  Bison:
----------------------------------------------------------------------------
    Description:
      Bison is a general-purpose parser generator that converts an
      annotated context-free grammar into a deterministic LR or generalized
      LR (GLR) parser employing LALR(1) parser tables. 

     Versions:
        Bison/3.0.4-GCCcore-8.1.0
        Bison/3.0.4

----------------------------------------------------------------------------
  For detailed information about a specific "Bison" module (including how to load the modules) use the module's full name.
  For example:

     $ module spider Bison/3.0.4
----------------------------------------------------------------------------

----------------------------------------------------------------------------
  lang/Bison:
----------------------------------------------------------------------------
    Description:
      Bison is a general-purpose parser generator that converts an
      annotated context-free grammar into a deterministic LR or generalized
      LR (GLR) parser employing LALR(1) parser tables. 

     Versions:
        lang/Bison/3.0.4-GCCcore-8.1.0
        lang/Bison/3.0.4

----------------------------------------------------------------------------
  For detailed information about a specific "lang/Bison" module (including how to load the modules) use the module's full name.
  For example:

     $ module spider lang/Bison/3.0.4
----------------------------------------------------------------------------



module load

To load a module type module load <module name>. You can append a version number to load a specific instance of a package. Note the <tab> key can be used to complete the command.

Load a module

$ module load lang/Bison <tab> <tab>
lang/Bison Bison/3.0.4-GCCcore-8.1.0
lang/Bison/3.0.4
$ module load lang/Bison

In this example we have the option of the default version of Bison, Bison built with eith the GCCcore or default toolchains.  If no version is specified, then the default module is loaded.

Load a specific version

$ module load lang/Bison/3.0.4 <tab> <tab>
lang/Bison/3.0.4 Bison/3.0.4-GCCcore-8.1.0
$ module load lang/Bison/3.0.4-GCCcore-8.1.0
$ module list

Currently Loaded Modules:
1) compiler/GCCcore/8.1.0 2) lang/Bison/3.0.4-GCCcore-8.1.0

Notice how the GCCcore compiler is loaded as Bison is dependent on this.

module list

To list currently loaded modules type module list

List currently loaded modules

$ module list

Currently Loaded Modules:
1) lang/Bison/3.0.4

module purge

module purge unloads all loaded modules.

module unload

To unload a module use the module unload command

Unload a module

$ module unload lang/Bison/3.0.4-GCCcore-8.1.0
$ module list

Currently Loaded Modules:
1) compiler/GCCcore/8.1.0

Notice how the compiler toolchain is not unloaded.

Other useful commands

Command

Description

module whatis <module>

Gives a short description of the module

module show <module>

Gives a long description of the module and displays what environment variables a module will modify

module help <module>

Gives a long description of the module (e.g. website, license)

Command syntax

Module help

$ module help

Usage: module [options] sub-command [args ...]

Options:
-h -? -H --help This help message
-s availStyle --style=availStyle Site controlled avail style: system
(default: system)
--regression_testing Lmod regression testing
-D Program tracing written to stderr
--debug=dbglvl Program tracing written to stderr
--pin_versions=pinVersions When doing a restore use specified version, do not follow defaults
-d --default List default modules only when used with avail
-q --quiet Do not print out warnings
--topic=topic help topics: modfuncs envvars
--expert Expert mode
-t --terse Write out in machine readable format for commands: list, avail, spider, savelist
--initial_load loading Lmod for first time in a user shell
--latest Load latest (ignore default)
--ignore_cache Treat the cache file(s) as out-of-date
--novice Turn off expert and quiet flag
--raw Print modulefile in raw output when used with show
-w twidth --width=twidth Use this as max term width
-v --version Print version info and quit
-r --regexp use regular expression match
--gitversion Dump git version in a machine readable way and quit
--dumpversion Dump version in a machine readable way and quit
--localvar=localvarA local variables needed to be set after this commands execution
--check_syntax --checkSyntax Checking module command syntax: do not load
--config Report Lmod Configuration
--mt Report Module Table State
--timer report run times
--force force removal of a sticky module or save an empty collection
--redirect Send the output of list, avail, spider to stdout (not stderr)
--no_redirect Force output of list, avail and spider to stderr
--show_hidden Avail and spider will report hidden modules
--spider_timeout=timeout a timeout for spider


module [options] sub-command [args ...]

Help sub-commands:
------------------
help prints this message
help module [...] print help message from module(s)

Loading/Unloading sub-commands:
-------------------------------
load | add module [...] load module(s)
try-load | try-add module [...] Add module(s), do not complain if not found
del | unload module [...] Remove module(s), do not complain if not found
swap | sw | switch m1 m2 unload m1 and load m2
purge unload all modules
refresh reload aliases from current list of
modules.
update reload all currently loaded modules.

Listing / Searching sub-commands:
---------------------------------
list List loaded modules
list s1 s2 ... List loaded modules that match the pattern
avail | av List available modules
avail | av string List available modules that contain "string".
spider List all possible modules
spider module List all possible version of that module file
spider string List all module that contain the "string".
spider name/version Detailed information about that version of the module.
whatis module Print whatis information about module
keyword | key string Search all name and whatis that contain "string".

Searching with Lmod:
--------------------
All searching (spider, list, avail, keyword) support regular expressions:

spider -r '^p' Finds all the modules that start with `p' or `P'
spider -r mpi Finds all modules that have "mpi" in their name.
spider -r 'mpi$ Finds all modules that end with "mpi" in their name.

Handling a collection of modules:
--------------------------------
save | s Save the current list of modules to a user defined "default" collection.
save | s name Save the current list of modules to "name" collection.
reset The same as "restore system"
restore | r Restore modules from the user's "default" or system default.
restore | r name Restore modules from "name" collection.
restore system Restore module state to system defaults.
savelist List of saved collections.
describe | mcc name Describe the contents of a module collection.

Deprecated commands:
--------------------
getdefault [name] load name collection of modules or user's "default" if no name given.
===> Use "restore" instead <====
setdefault [name] Save current list of modules to name if given, otherwise save as the default list for you the user.
===> Use "save" instead. <====

Miscellaneous sub-commands:
---------------------------
show modulefile show the commands in the module file.
use [-a] path Prepend or Append path to MODULEPATH.
unuse path remove path from MODULEPATH.
tablelist output list of active modules as a lua table.

Important Environment Variables:
--------------------------------
LMOD_COLORIZE If defined to be "YES" then Lmod prints
properties and warning in color.

--------------------------------------------------------------------------

Lmod Web Sites

Documentation: http://lmod.readthedocs.org
Github: https://github.com/TACC/Lmod
Sourceforge: https://lmod.sf.net
TACC Homepage: https://www.tacc.utexas.edu/research-development/tacc-projects/lmod

To report a bug please read http://lmod.readthedocs.io/en/latest/075_bug
_reporting.html
--------------------------------------------------------------------------

Modules based on Lua: Version 6.5.1 2016-08-17 15:44

by Robert McLay mclay@tacc.utexas.edu


Saving and loading collections of modules

You can save and restore collections of modules you currently have loaded.  The saved module file can be found in /users/abc123/.lmod.d/filename.

Saving modules
[abs4@login2(viking) tests]$ module list

Currently Loaded Modules:
  1) compiler/GCCcore/7.3.0
  2) tools/binutils/2.30-GCCcore-7.3.0
  3) compiler/GCC/7.3.0-2.30
  4) system/CUDA/9.2.88-GCC-7.3.0-2.30
  5) toolchain/gcccuda/2018b
 

[abs4@login2(viking) tests]$ module save lotsofmods
Saved current collection of modules to: "lotsofmods"

[abs4@login2(viking) tests]$ module savelist
Named collection list :
  1) lotsofmods
[abs4@login2(viking) tests]$ module purge
[abs4@login2(viking) tests]$ module list
No modules loaded
[abs4@login2(viking) tests]$ module restore lotsofmods 
Restoring modules from user's lotsofmods
[abs4@login2(viking) tests]$ module list

Currently Loaded Modules:
  1) compiler/GCCcore/7.3.0
  2) tools/binutils/2.30-GCCcore-7.3.0
  3) compiler/GCC/7.3.0-2.30
  4) system/CUDA/9.2.88-GCC-7.3.0-2.30
  5) toolchain/gcccuda/2018b


Installing modules

If you do not find the application you need or you would like a different version to what is available, please get in touch by emailing itsupport@york.ac.uk 

Please send the following information if you can

  • Name of software
  • URL to either the git repository or software page.




  • No labels