Softwares
This section presents the various kinds of software products (binaries, libraries, scripts and tools) available on the center. It is organized as follows. After generally explaining the different kinds of software on the center, we will focus on specific cases (restricted and purchased products). Finally, we will talk about the software life cycle, from the installation request to the product removal.
Generalities on software
Lots of tools and products are available on the supercomputer. A distinction is made between the OS and CCC software.
OS software
They are software products provided by the operating system. They are installed by packages (rpm) and are locally stored on each node.
All common Linux software products enter in this category, such as:
- shells (bash, tcsh),
- common scripting tools (cat, sed, awk, …)
- editors (vi, emacs, gedit, …),
- minimal installations of common scripting language (perl, python).
Updates occur during maintenance or during production only if they do not impact the operating system of the node.
CCC software
CCC software products are the third-party dedicated tools or dedicated compilations. They are shared by all center nodes and are installed by TGCC-CCRT dedicated service(s) during production. We prefer the term CCC software products over center software which is ambiguous.
Contrary to the OS software products, CCC software products are not within the standard operating system paths for binaries or libraries (eg. /usr/bin or /usr/lib64).
Each product is installed in a dedicated directory and requires an update of environment variables like and before use. These environment updates are handled by the module tool detailed in the Environment management section.
Updates occur during production as they do not interrupt nor interfere with the operating system installation.
Software and module
A CCC software product requires an environment update before use. The module command is the tool for it, so a module exists for each CCC software product.
An OS software product is usually not referred to by a module, except when:
- it is usually the case in other computing centers (ex: tcl)
- there is a CCC software version of it (ex: valgrind): it helps to avoid conflicts between the OS and CCC installation.
Products referenced by module have been organized into categories:
- applications: simulation products
- environment: defines the user/group environment
- tools: development tools
- graphics: visualization or image manipulation tools
- parallel: parallel execution software such as MPI
- libraries: third-party libraries
- compilers: the various compilers
A domain-oriented view is provided by module search <keyword>. To list the valid keywords use:
module help|show products/keywords
Software toolchains
Warning
Please refer to internal technical documentation to get information about available toolchains.
This approach provides a variety of compilation / runtime environments to users with consistency across products. To consult the list of available builds for a given product, type module help <product>.
The selection between toolchains is made with two modules flavor/buildcompiler/<compiler>/<version> and flavor/buildmpi/<mpi>/<version>. It allows you to change the toolchain used for any loaded product regardless of the Intel compiler and MPI implementation used at runtime, which is determined by your current intel and mpi modules loaded.
More information on the flavor mechanism can be found on the dedicated section.
The module flavor/buildcompiler/<compiler>/<version> lets you choose the version of the Intel compiler whereas the module flavor/buildmpi/<mpi>/<version> lets you choose the MPI implementation and version.
Product Life cycle
Here are the phases of a software product life cycle, explained chronologically from its installation request to its deprecation and removal.
Installation request
New products and/or product update(s) can be requested by mail to the TGCC-CCRT hotline.
Requests are usually accepted if:
- the product is the last stable version,
- the product is useful to many users,
- the product has no license issue.
There are also special cases, namely:
- an installation for a group of persons is not possible since these persons are not part of the same user container,
- or the product access should be restricted (see Installation request and restricted products),
- or the product requires a license server (see Installation request and purchased products).
Installation phase
If the installation request is approved, we will proceed to the installation itself:
- for an OS software product, it should be done at the next maintenance (or before if this is deemed safe).
- and for an CCC software product, it should take several days.
Note
Those are estimated installation times. If technical difficulties occur the installation may take longer (example: licensed products)
Newly installed CCC software maybe listed with:
module help|show products/newinstall
Production phase
During the production, the software product should be operational. If you detect an issue, a bug or a missing feature, please report it to the TGCC-CCRT hotline.
End-of-life and removal
An OS software product is considered obsolete when either the distribution considers it as such or when an update has been planned for the next maintenance.
For CCC software products, we try to respect the following rules. For each CCC software product, the center favors versions with the least bugs, the most features and the best performances. Hence the last stable version of a product is very welcome (new features, better performances and bug corrections). So when a new version of a product is installed, previous versions may become obsolete. To be more specific, we will only keep:
- the latest version,
- its last known stable(s) version(s) (for reference purpose),
- and the version(s) before retro-compatibility issues (mainly API break).
Python
Available versions and toolchains
To display all Python versions, use the command module av -t python3:
python3/x.y.z
python3/x.y.z(stable)
python3/x.y.z(unstable)
The (stable) version only changes for security issues. The (unstable) version changes everytime a user asks for a new package or an update. We higly recommand the (stable) one for virtualenv users.
There are at least three types of Python distributions:
- System:
- Only packages that could be compiled with the operating system GCC
- GCC+OpenMPI:
- Compiled with a recent GCC and Open MPI
- GCC+OpenMPI+CUDA
- Compiled with a recent GCC, Open MPI and CUDA
- For AI applications (PyTorch, Tensorflow…)
Display available configurations with the command module help python3/<version>.
-------------------------------------------------------------------
Module Specific Help for /ccc/etc/modulefiles/tools/python3/<version>:
Software description:
Name : Python lang
Description : Python programming language
Version : <versions>
Software configuration(s):
Copy/paste one of the following line ("module purge" could be required).
Setup(s) for users based on GCC compiler:
0 : module load gcc/<versions> mpi/openmpi/<versions> flavor/python3/cuda-<version> python3/<version>
1 : module load gcc/<versions> mpi/openmpi/<versions> python3/<version>
Setup(s) without specific requirement:
2*: module load python3/<version>
-------------------------------------------------------------------
For instance, to load the GCC+Openmpi+CUDA distribution:
$ module load gcc/<version> mpi/openmpi/<version> flavor/python3/cuda-<version> python3/<version>
To list all available Python packages in your current environment, run pip3 list.
Adding new module
Adding new modules in the distribution
In order to request the installation of one or several python modules, please refer to the Installation request part.
Adding new modules locally, through a virtual environment
Load the desired Python environment:
$ module purge ; module load [...] python3/<version>
Create a virtual environment based on this environment:
$ python3 -m venv <my_virtual_env> --system-site-packages
--system-site-packages option indicates that the original Python site-packages will be available to the new environment. Without this option, the new virtual environment will be empty and the environment should be rebuilt from scratch.
Activate it:
source <my_virtual_env>/bin/activate
Import the source code of the Python modules you need to install, for instance: maze-3.0.0.tar.gz (see Data transfers).
Extract the folder from the archive:
tar xfz <module.tar.gz>
Go in the folder containing the installation files:
cd <module>
Install the python module:
python3 setup.py install
You may need to install one or several dependencies to complete the installation. Proceed in the same way for each of those. It is recommended to identify beforehand the aforementioned dependencies either on a local computer and/or by reading the requirements.txt file that should be at the root of the Python package.
Machine learning and artificial intelligence
Pytorch
In order to use Pytorch, you may use the following environment:
$ module purge
$ module load gcc/<version> mpi/openmpi/<version> flavor/python3/cuda-<version> python3/<version>
$ python3
Python 3.x.y (main, XXX XX 20XX, XX:XX:XX) [GCC X.Y.Z] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>>
Tensorflow
In order to use Tensorflow, you may use the following environment:
$ module purge
$ module load gcc/<version> mpi/openmpi/<version> flavor/python3/cuda-<version> python3/<version>
$ python3
Python 3.x.y (main, XXX XX 20XX, XX:XX:XX) [GCC X.Y.Z] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>
Jupyter-lab
Jupyter-lab is available on irene. You may use the following commands to start Jupyter-lab:
$ module purge
$ module load python3/<version>
# or module load gcc/<version> mpi/openmpi/<version> python3/<version>
# or module load gcc/<version> mpi/openmpi/<version> flavor/python3/cuda-<version> python3/<version>
$ jupyter-lab
Warning
Jupyter-lab is not available with the Intel toolchain.
It is recommended to use NiceDCV for better stability.
Alphafold
We provide access to the DeepMind’s Alphafold software via a container. Included are the OCI image, the complete database and a set of scripts for easier usage.
Available versions
The version available is 2.3.1, and the database includes the latest versions of all files as of December 2022.
Using AlphaFold on TGCC
AlphaFold requires access to the |default_GPU_partition| partition. It may works on other GPU partition. Upon loading the module, you will receive a path to our AlphaFold Readme file.
$ module load alphafold
First import the image using pcocc-rs.
$ pcocc-rs image import docker-archive:${ALPHAFOLD_IMAGE_ROOT}/alphafold-2022.10.24.tar user:alphafold-231
Next, please copy the scripts we have provided to utilize AlphaFold via pcocc-rs.
$ cp -r ${ALPHAFOLDRUN_ROOT}/run_squashfs-flat ${CCCSCRATCHDIR}/<my_test_case>
You have the option to select between monomer or multimer cases. This can be configured in the submission script, with monomer being the default setting. The output directory should exist before sumbitting the script.
$ cat ${ALPHAFOLDRUN_ROOT}/run_squashfs-flat/submit_script_alphafold-231_squashfs-flat.sh
#!/bin/bash
#MSUB -e AF_%J.e
#MSUB -o AF_%J.o
#MSUB -n 1 # nombres de tâches MPI
#MSUB -c |cores_per_GPU_on_default_partition| # number of cores to be booked. You need |cores_per_GPU_on_default_partition| cores to get one GPU.
##MSUB -x #node exclusivity, to be add for big cases. (if you encounter a memory issue)
#MSUB -T 20000
#MSUB -q |default_GPU_partition| # hybrid may be used as well
#MSUB -A <group>
#MSUB -m work,scratch
module purge
module load alphafold
export CCC_ALPHAFOLD_DATABASE
export CCC_ALPHAFOLD_IMAGE="alphafold-231"
# Use the database stored on hdd to test the impact
#export ALPHAFOLD_USE_DB_HDD=true
# the output directory should exist before launching the job. Adapt to your need.
export ALPHAFOLD_OUTPUT="$(pwd)/output-squash-flat"
# to edit to match your need
export ALPHAFOLD_INPUT=${ALPHAFOLDRUN_ROOT}/exemple_CCRT/input.fasta
# Replace ${ALPHAFOLDRUN_ROOT}/run_pcocc-rs_squashfs-flat_|default_GPU_partition|.sh by the path to your submission script if you want to use a tailored version
ccc_mprun ${ALPHAFOLDRUN_ROOT}/run_squashfs-flat/run_pcocc-rs_squashfs-flat_|default_GPU_partition|_monomer.sh --max_template_date 2020-05-14 --fasta_paths $ALPHAFOLD_INPUT > AF-231-squash-flat.log
Finally, simply submit the script as usual.
$ ccc_msub submit_script_alphafold-231_squashfs-flat.sh
The database includes the following files.
/ccc/products/alphafold-db-2022.10.24/system/default/db/
├── alphafold-db-compressed_hdd.sqsh
├── alphafold-db-compressed.sqsh
├── alphafold-db-flat_hdd.sqsh
├── alphafold-db-flat_t1.sqsh
├── bfd
│ ├── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_a3m.ffdata
│ ├── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_a3m.ffindex
│ ├── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_cs219.ffdata
│ ├── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_cs219.ffindex
│ ├── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_hhm.ffdata
│ └── bfd_metaclust_clu_complete_id30_c90_final_seq.sorted_opt_hhm.ffindex
├── mgnify
│ └── mgy_clusters.fa
├── params
│ ├── LICENSE
│ ├── params_model_1_multimer_v3.npz
│ ├── params_model_1.npz
│ ├── params_model_1_ptm.npz
│ ├── params_model_2_multimer_v3.npz
│ ├── params_model_2.npz
│ ├── params_model_2_ptm.npz
│ ├── params_model_3_multimer_v3.npz
│ ├── params_model_3.npz
│ ├── params_model_3_ptm.npz
│ ├── params_model_4_multimer_v3.npz
│ ├── params_model_4.npz
│ ├── params_model_4_ptm.npz
│ ├── params_model_5_multimer_v3.npz
│ ├── params_model_5.npz
│ └── params_model_5_ptm.npz
├── pdb70
│ ├── md5sum
│ ├── pdb70_a3m.ffdata
│ ├── pdb70_a3m.ffindex
│ ├── pdb70_clu.tsv
│ ├── pdb70_cs219.ffdata
│ ├── pdb70_cs219.ffindex
│ ├── pdb70_hhm.ffdata
│ ├── pdb70_hhm.ffindex
│ └── pdb_filter.dat
├── pdb_mmcif
│ ├── mmcif_files
│ └── obsolete.dat
├── pdb_seqres
│ └── pdb_seqres.txt
├── uniclust30
│ ├── UniRef30_2022_02_a3m.ffdata
│ ├── UniRef30_2022_02_a3m.ffindex
│ ├── UniRef30_2022_02_cs219.ffdata
│ ├── UniRef30_2022_02_cs219.ffindex
│ ├── UniRef30_2022_02_hhm.ffdata
│ ├── UniRef30_2022_02_hhm.ffindex
│ └── UniRef30_2022_02.md5sums
├── uniprot
│ ├── uniprot_sprot.fasta
│ └── uniprot_trembl.fasta
└── uniref90
└── uniref90.fasta
Note
For advanced use of AlphaFold, you may modify run_pcocc-rs_squashfs-flat_|default_GPU_partition|_monomer.sh and run_pcocc-rs_squashfs-flat_|default_GPU_partition|_multimer.sh as needed.
Note
AlphaFold is accessible to members of the alphafold UNIX group. To join, please contact support at please refer to internal documentation to get hotline email or please refer to internal documentation to get hotline phone.
Products list
This section catalogs all the software accessible on irene. For further details about these offerings, please engage with our support team. A number of applications within this list have the capability to execute computations on GPUs, as denoted by the “GPU Support” column. To clarify, this designation is exclusive to end-user applications. However, this does not preclude the possibility of other categories of products, such as tools and libraries, from being capable of running on GPUs. Should you require a GPU-aware version of any application not currently indicated as such, we encourage you to reach out to the support team for support.
Applications
| Name | Description | GPU Support |
|---|---|---|
| abinit | ABINIT is a package whose main program allows one to find the total energy, charge density and electronic structure of systems made of electrons and nuclei | |
| agate | Agate is mainly designed to work with the Abinit DFT code. However, it can perfectly read some VASP files and other commonly used format. Agate should help you to visualize in a glance any input file to make sure the structure you’re simulating is the one you want. | |
| alphafold | AI predicting protein folding structure | ✓ |
| cantera | Cantera is an open-source suite of tools for problems involving chemical kinetics, thermodynamics, and transport processes. | |
| conquest | CONQUEST is a large scale DFT electronic structure code, capable of both diagonalisation and linear scaling, or O(N), calculations. It is developed jointly by NIMS (National Institute for Materials Science, Japan), ISM (Institut des Science Moleculaires, University of Bordeaux) and UCL. | |
| cp2k | CP2K performs atomistic and molecular simulations of solid state, liquid, molecular and biological systems | |
| espresso | Quantum ESPRESSO is an integrated suite of computer codes for electronic-structure calculations and materials modeling at the nanoscale. It is based on density-functional theory, plane waves, and pseudopotentials (both norm-conserving and ultrasoft). | |
| fds | Fire Dynamics Simulator | |
| freefem | FreeFem is an implementation of a language dedicated to the finite element method. It enables you to solve Partial Differential Equations (PDE) easily. | |
| gate | GATE is a Monte-Carlo simulation toolkit for medical physics applications | |
| geant4 | Toolkit for the simulation of the passage of particles through matter | |
| gmt | Generic Mapping Tools | |
| gromacs | GROMACS (GROningen MAchine for Chemical Simulations) is a molecular dynamics simulation package | ✓ |
| lammps | LAMMPS is a molecular dynamics code, an acronym for Large-scale Atomic/Molecular Massively Parallel Simulator | ✓ |
| ls-prepost | LS-PrePost is an advanced pre and post-processor that is delivered free with LS-DYNA. The user interface is designed to be both efficient and intuitive. LS-PrePost runs on Windows, Linux, and Macs utilizing OpenGL graphics to achieve fast rendering and XY plotting. | |
| openfoam-plus | OpenFOAM distributed by OpenCFD (Open Source suite for field operations and manipulations). | |
| openfoam | Open Source suite for field operations and manipulations. | |
| permas | PERMAS is a general purpose software system to perform complex calculations in engineering using the finite element method (FEM), and to optimize the analyzed structures and models. | |
| prolb | ProLB is an innovative Computational Fluid Dynamics (CFD) software solution. Based on the Lattice-Boltzmann method, its succesfully-validated solver performs inherently transient simulations of highly complex flows with a competitive turnaround time. ProLB??s accurate aerodynamic and aeroacoustic modeling allows engineers to make early design decisions that optimize and shorten the product development process. | |
| qagate | qAgate is the new Qt interface for agate. It includes all the features of Agate with a new user friendly look. It also includes sommes ‘external’ tools to help some users with fast analysis. | |
| salome | SALOME is an open-source software that provides a generic platform for Pre- and Post-Processing for numerical simulation. It is based on an open and flexible architecture made of reusable components. | |
| saturne | Code_Saturne is a EDF’s general purpose Computational Fluid Dynamics (CFD) software | |
| siesta | Spanish Initiative for Electronic Simulations with Thousands of Atoms | |
| stack | Stack is a program for developing Haskell projects | |
| wps | The Weather Research and Forecasting (WRF) Model is a next-generation mesoscale numerical weather prediction system designed to serve both atmospheric research and operational forecasting needs. WPS is the WRF Preprocessing System. | |
| wrf | The Weather Research and Forecasting (WRF) Model is a next-generation mesoscale numerical weather prediction system designed to serve both atmospheric research and operational forecasting needs |
Compilers
| Name | Description |
|---|---|
| aocc-compiler | The AOCC compiler system |
| aocl-libm | The AOCL AMD Math Library |
| c++/gnu | GNU C++ compiler (g++) |
| c++/intel | Intel C++ compiler (icpc) |
| c++/inteloneapi | Intel oneAPI C++ compiler (icpx) |
| c++/llvm | LLVM C++ compiler (clang++) |
| c++/nvidia | Nvidia C++ compiler (nvc++) |
| c++/pgi | PGI C++ compiler (pgCC) |
| c/gnu | GNU C compiler (gcc) |
| c/intel | Intel C compiler (icc) |
| c/inteloneapi | Intel oneAPI C compiler (icx) |
| c/llvm | LLVM C compiler (clang) |
| c/nvidia | Nvidia C compiler (nvc) |
| c/pgi | PGI C compiler (pgcc) |
| fortran/gnu | GNU Fortran compiler (gfortran) |
| fortran/intel | Intel Fortran compiler (ifort) |
| fortran/inteloneapi | Intel oneAPI Fortran compiler (ifx) |
| fortran/llvm | LLVM Fortran compiler (flang) |
| fortran/nvidia | Nvidia FORTRAN compiler (nvfortran) |
| fortran/pgi | PGI Fortran compiler (pgf77/pgf90) |
| gnu | GNU C (gcc), C++ (g++) and Fortran (gfortran) compilers |
| intel | Intel C (icc), C++ (icpc) and Fortran (ifort) compilers |
| inteloneapi | Intel oneAPI C (icx), C++ (icpx), DPC++ (dpcpp) and Fortran (ifx) compilers |
| java/openjdk | Open Java Runtime and Development Kit |
| java/oracle | Oracle Java Runtime and Development Kit |
| llvm | The LLVM Project is a collection of modular and reusable compiler (Clang, Clang++) and toolchain technologies. |
| nvhpc | Nvidia C (nvc), C++ (nvc++) and Fortran (nvfortran) compilers |
Graphics
| Name | Description |
|---|---|
| ensight | Post-processing and Visualization for Scientific Data |
| ferret | Software for vizualisation and data analysing |
| ghostscript | An interpreter for the PostScript language and for PDF, and related software and documentation |
| gnuplot | Gnuplot is a portable command-line driven graphing utility for Linux, OS/2, MS Windows, OSX, VMS, and many other platforms. |
| grace | Visualization software |
| hdfview | HDFView is a visual tool for browsing and editing HDF4 and HDF5 files. |
| idl | IDL is a solution for data analysis, data visualization, and software application development |
| imagemagick | Toolkit for manipulation of graphic images, including conversion of images between a variety of different formats |
| libpng | libpng is the official PNG reference library. |
| mesa | Mesa libGL/libGLU libraries |
| ncl_ncarg | NCAR Graphics is primarily a graphics package, with some limited data analysis through the Ngmath package. |
| ncview | Ncview is a visual browser for netCDF format files |
| paraview | Open source scientific visualization |
| ploticus | Ploticus is a free GPL software utility that can produce various types of plots and graphs. |
| qt | Cross-platform application and UI development framework |
| tecplot | Visualization software tool |
| visit | VisIt - Visualization Tool |
| vmd | VMD is a molecular visualization program for displaying, animating, and analyzing large biomolecular systems using 3-D graphics and built-in scripting. |
| vtk | The Visualization Toolkit (VTK) is an open-source, freely available software system for 3D computer graphics, image processing and visualization |
| yaml-cpp | yaml-cpp is a YAML parser and emitter in C++ matching the YAML 1.2 spec. |
Libraries
| Name | Description |
|---|---|
| adge | |
| amd-fftw | Fastest Fourier Transform in the West |
| aocl-libmem | AOCL-LibMem is AMD’s optimized implementation of memory/string functions. |
| aocl-rng | AMD Random Number Generator Library is a pseudorandom number generator library. A pseudo-random number generator (PRNG) produces a stream of variates that are independent and statistically indistinguishable from a random sequence. AMD Random Number Generator Library provides a comprehensive set of statistical distribution functions which are founded on various underlying uniform distribution generators (base generators) including Wichmann-Hill and Mersenne Twister. The library contains five base generators and twenty-three distribution generators. In addition users can supply a custom built generator as the base generator for all of the distribution generators. |
| aocl-securerng | The AMD Secure Random Number Generator (RNG) is a library that provides APIs to access the cryptographically secure random numbers generated by AMD’s hardware-based random number generator implementation. These are high quality robust random numbers designed to be suitable for cryptographic applications. The library makes use of RDRAND and RDSEED x86 instructions exposed by the AMD hardware. Applications can just link to the library and invoke either a single or a stream of random numbers. The random numbers can be of 16-bit, 32-bit, 64-bit or arbitrary size bytes. |
| aocl-sparse | AOCL-Sparse contains basic linear algebra subroutines for sparse matrices and vectors optimized for AMD processors. It is designed to be used with C and C++. |
| aocl | AMD Optimizing CPU Libraries (AOCL) |
| apr-util | Apache Portable Runtime libraries |
| apr | Apache Portable Runtime libraries |
| armadillo | Armadillo is a high quality C++ linear algebra library, aiming towards a good balance between speed and ease of use |
| blas/aocl | Basic Linear Algebra Subprograms |
| blas/mkl | Intel Math Kernel Library BLAS routines |
| blas/netlib | Netlib Basic Linear Algebra Subprograms |
| blis | BLIS is a portable software framework for instantiating high-performance BLAS-like dense linear algebra libraries |
| blis/aocl | BLIS is a portable software framework for instantiating high-performance BLAS-like dense linear algebra libraries |
| blitz | Blitz++ provides dense arrays and vectors, random number generators, and small vectors (useful for representing multicomponent or vector fields). |
| boost | Boost C++ libraries |
| cgal | CGAL is a software project that provides easy access to efficient and reliable geometric algorithms in the form of a C++ library. |
| cgns | CFD General Notation System |
| cudnn | The NVIDIA CUDA Deep Neural Network library (cuDNN) is a GPU-accelerated library of primitives for deep neural networks. |
| cwipi | A dynamic parallel code coupler and coupling with parallel interpolation interface |
| czmq | High-level C binding for ZeroMQ |
| dtcmp | The Datatype Comparison (DTCMP) Library provides pre-defined and user-defined comparison operations to compare the values of two items which can be arbitrary MPI datatypes. |
| eccodes | ecCodes provides an application programming interface and a set of tools for decoding and encoding messages in GRIB format |
| editline | A small replacement for GNU readline() for UNIX |
| eigen | Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms |
| elpa | Eigenvalue soLvers for Petaflop Applications |
| fftw2 | Discrete Fourier Transform |
| fftw3 | Fastest Fourrier Transform in the West |
| fftw3/aocl | Fastest Fourier Transform in the West |
| fftw3/mkl | Intel Math Kernel Library FFTW3 routines |
| fftw3/vanilla | Fastest Fourier Transform in the West |
| fltk | FLTK is a cross-platform C++ GUI toolkit for UNIX/Linux |
| fmt | fmt (formerly cppformat) is an open-source formatting library. It can be used as a fast and safe alternative to printf and IOStreams. |
| fox | A Fortran library for XML |
| gdal | gdal is a translator library for raster geospatial data formats that is released under an X/MIT style |
| geos | Geometry Engine Open Source |
| glpk | The GLPK (GNU Linear Programming Kit) package is intended for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems |
| gmp | GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. |
| grib | The ECMWF GRIB API is an application program interface accessible from C and FORTRAN programs developed for encoding and decoding WMO FM-92 GRIB edition 1 and edition 2 messages. |
| gsl | GNU Scientific Library (GSL) is a numerical library for C and C++ programmers |
| h5utils | h5utils is a set of utilities for visualization and conversion of scientific data in the free, portable HDF5 format. |
| hdf5 | Hierarchical Data Format |
| hypre | Hypre is a library for solving large, sparse linear systems of equations on massively parallel computers |
| jansson | C library for encoding, decoding and manipulating JSON data |
| jasper | Common jpeg library |
| kokkos-kernels | KokkosKernels implements local computational kernels for linear algebra and graph operations, using the Kokkos shared-memory parallel programming model. |
| kokkos-tools | Performance profiling tools that can be optionally integrated into Kokkos-based applications and libraries. |
| kokkos | Kokkos Core implements a programming model in C++ for writing performance portable applications targeting all major HPC platforms. Kokkos Core is part of the Kokkos C++ Performance Portability Programming EcoSystem, which also provides math kernels (kokkos-kernels), as well as profiling and debugging tools (kokkos-tools). |
| lapack/aocl | Linear Algebra PACKage |
| lapack/mkl | Intel Math Kernel Library LAPACK routines |
| lapack/netlib | Netlib Linear Algebra PACKage |
| libaec | Libaec provides fast lossless compression of 1 up to 32 bit wide signed or unsigned integers (samples). The library achieves best results for low entropy data as often encountered in space imaging instrument data or numerical model output from weather or climate simulations. While floating point representations are not directly supported, they can also be efficiently coded by grouping exponents and mantissa. |
| libccc_user | libccc_user allows to access inside a job to information about execution time or memory consumed by the job |
| libcircle | libcircle is an API for distributing embarrassingly parallel workloads using self-stabilization. |
| libcudacompat | We define binary compatibility as a set of guarantees provided by the library, where an application targeting the said library will continue to work when dynamically linked against a different version of the library. |
| libflame/aocl | libflame is a portable library for dense matrix computations, providing much of the functionality present in LAPACK, developed by current and former members of the Science of High-Performance Computing (SHPC) group in the Institute for Computational Engineering and Sciences at The University of Texas at Austin. libflame includes a compatibility layer, lapack2flame, which includes a complete LAPACK implementation. |
| libgd | GD is an open source code library for the dynamic creation of images by programmers. |
| libint | a high-performance library for computing Gaussian integrals in quantum mechanics |
| libmpc | Mpc is a C library for the arithmetic of complex numbers with arbitrarily high precision and correct rounding of the result. |
| libmxml | Mini-XML is a small XML library that you can use to read and write XML and XML-like data files in your application without requiring large non-standard libraries |
| libnag | the NAG Library is a commercially available collection of numerical and statistical algorithms |
| libqglviewer | libQGLViewer is a C++ library based on Qt that eases the creation of OpenGL 3D viewers. |
| libquip | The QUIP package is a collection of software tools to carry out molecular dynamics simulations. |
| libtar | libtar is a library for manipulating tar files from within C programs. |
| libtree | libtree is a tool that turns ldd into a tree, explains why shared libraries are found and why not and optionally deploys executables and dependencies into a single directory |
| libxc | a library of exchange-correlation functionals for density-functional theory |
| libxsmm | LIBXSMM is a library for specialized dense and sparse matrix operations as well as for deep learning primitives such as small convolutions targeting Intel Architecture |
| loki | Loki is a C++ library of designs, containing flexible implementations of common design patterns and idioms. |
| lwgrp | The light-weight group library defines data structures and collective operations to group MPI processes as an ordered set. Such groups are useful as substitutes for MPI communicators when the overhead of communicator creation is too costly. |
| magma | Matrix Algebra on GPU and Multicore Architectures |
| math/nvidia | Nvidia math libraries (like blas) |
| maven | Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information. |
| med | The purpose of the MED module is to provide a standard for storing and recovering computer data associated to numerical meshes and fields, and to facilitate the exchange between codes and solvers. |
| mesquite | Mesh-Quality Improvement Library |
| metis | Serial Graph Partitioning and Fill-reducing Matrix Ordering |
| mkl | Intel Math Kernel Library |
| mpfr | The MPFR library is a C library for multiple-precision floating-point computations with correct rounding. |
| mumps | MUltifrontal Massively Parallel Sparse direct Solver |
| nccl | Optimized primitives for collective multi-GPU communication |
| nccl_rdma_sharp_plugin | Optimized primitives for collective multi-GPU communication |
| netcdf-c | Network Common Data Form (C) |
| netcdf-cxx4 | The netCDF-4 C++ API |
| netcdf-fortran | Network Common Data Form fortran support lib |
| netcdf95 | Alternate Fortran interface to the NetCDF library |
| openblas | OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version. |
| opencv | Visualization software tool |
| p3dfft | Scalable Framework for Three-Dimensional Fourier Transforms |
| parmetis | Parallel Graph Partitioning and Fill-reducing Matrix Ordering |
| parpack | Parallel ARPACK (PARPACK) and ARPACK. ARPACK is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. |
| pastix | Parallel Sparse Matrix Package (sparse linear solver) |
| pcre | The PCRE package contains Perl Compatible Regular Expression libraries. |
| petsc | Portable and extensible toolkit for scientific computation |
| plumed | An open source library for free energy calculations in molecular systems which works together with some of the most popular molecular dynamics engines |
| pmix | Process Management Interface (PMI) is a means of exchanging wireup information needed for interprocess communication. PMI Exascale is an extended version of the PMI standard specifically designed to support clusters up to and including exascale sizes. |
| pnetcdf | Parallel netCDF (PnetCDF) is an I/O library that supports data access to netCDF files in parallel |
| proj | Cartographic Projections library |
| ptscotch | Mesh generation library in Parallel |
| pytorch | An open source deep learning platform that provides a seamless path from research prototyping to production deployment. |
| scalapack/aocl | AOCL Scalable Linear Algebra PACKage |
| scalapack/mkl | Intel Math Kernel Library ScaLAPACK routines |
| scalapack/netlib | Netlib Scalable Linear Algebra PACKage |
| scikit-learn | Simple and efficient tools for predictive data analysis |
| scotch | Mesh generation library |
| serf | High performance C-based HTTP client library built upon the Apache Portable Runtime (APR) library |
| sharp | Mellanox backend for hcoll |
| silo | Silo is a library for reading and writing a wide variety of scientific data to binary, disk files. The files Silo produces and the data within them can be easily shared and exchanged between wholly independently developed applications running on disparate computing platforms. |
| slepc | Scalable Library for Eigenvalue Problem computation |
| speos | |
| suitesparse | a suite of sparse matrix software |
| sundials | SUite of Nonlinear and DIfferential/ALgebraic equation Solvers |
| superlu | SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations on high performance machines |
| superlu_dist | SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations on high performance machines |
| tbb | Intel Threading Building Blocks Library |
| tensorflow | An open-source software library for Machine Intelligence |
| thrust | Thrust is a parallel algorithms library which resembles the C++ Standard Template Library (STL). |
| trilinos | The Trilinos Project provides algorithms within an object-oriented software framework for the solution of large-scale, complex multi-physics engineering and scientific problems. |
| ucx | Mellanox backend for IB |
| voroplusplus | Voro++ is a software library for carrying out three-dimensional computations of the Voronoi tessellation. |
| wannier90 | Wannier90 is an open-source code (released under GPLv2) for generating maximally-localized Wannier functions and using them to compute advanced electronic properties of materials with high efficiency and accuracy. |
| wi4pthread | Library developed by TGCC to solve threads placement issues on KNL partition |
| x264 | x264 is a library and application for encoding video streams into the H.264/MPEG-4 AVC compression format |
| xerces-c | Xerces-C++ is a validating XML parser written in a portable |
| xz | compression software |
| yade | Yade is an extensible open-source framework for discrete numerical models, focused on Discrete Element Method. |
| zeromq | ZeroMQ looks like an embeddable networking library but acts like a concurrency framework. |
Parallel
| Name | Description |
|---|---|
| cuda | CUDA (Compute Unified Device Architecture) development tools for NVIDIA GPU |
| hcoll | Mellanox backend for MPI collectives |
| mpi/intelmpi | Intel MPI Library |
| mpi/openmpi | Open source MPI-2 implementation |
| mpi/wi4mpi | Allows to switch to any MPI implementation without recompiling |
Tools
| Name | Description |
|---|---|
| advisor | Threading design and prototyping tool for software architects |
| ant | Apache Ant is a Java library and command-line tool whose mission is to drive processes described in build files as targets and extension points dependent upon each other. The main known usage of Ant is the build of Java applications. |
| antlr | ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files |
| arm-forge | C, C++ and F90 profiler and parallel Debugger for high performance and multithreaded Linux applications (DDT, MAP…) |
| autoconf | Autoconf is an extensible package of M4 macros that produce shell scripts to automatically configure software source code packages. |
| automake | Automake is a tool for automatically generating Makefile.in files compliant with the GNU Coding Standards. |
| blender | Blender is the free and open source 3D creation suite. |
| cdo | CDO (Climate Data Operators) is a collection of command line Operators to manipulate and analyse Climate and NWP model Data. |
| cmake | Cross-platform, open-source build system |
| cppunit | Unit testing framework module for the C++ programming language, described as a C++ port of JUnit. |
| cubegui | cubegui, which is used as performance report explorer for Scalasca and Score-P |
| cubelib | cubelib, which is used as performance report explorer for Scalasca and Score-P |
| cubew | Cubew, which is used as performance report explorer for Scalasca and Score-P |
| cylc | Cylc is a workflow engine for cycling systems |
| darshan | Scalable HPC I/O characterization tool designed to capture an accurate picture of application I/O behavior, including properties such as patterns of access within files, with minimum overhead. |
| ddd | GNU DDD (Data Display Debugger), graphical front-end for GDB debugger |
| dmtcp | DMTCP (Distributed MultiThreaded Checkpointing) transparently checkpoints a single-host or distributed computation in user-space – with no modifications to user code or to the O/S. |
| doxygen | Doxygen is the de facto standard tool for generating documentation from annotated C++ sources, but it also supports other popular programming languages such as C, Objective-C, C#, PHP, Java, Python, IDL (Corba and Microsoft flavors), Fortran, VHDL, Tcl, and to some extent D. |
| ffmpeg | FFmpeg is the leading multimedia framework, able to decode, encode, transcode, mux, demux, stream, filter and play pretty much anything that humans and machines have created. |
| flux-core | Core services for the Flux resource management framework |
| flux-sched | Core services for the Flux resource management framework |
| gdb | A GNU source-level debugger for C, C++, Java and other languages |
| geany | Geany is a powerful, stable and lightweight programmer’s text editor that provides tons of useful features without bogging down your workflow. |
| git | Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency |
| gitlab-runner | GitLab Runner is the open source project that is used to run your jobs and send the results back to GitLab. It is used in conjunction with GitLab CI, the open-source continuous integration service included with GitLab that coordinates the jobs. |
| glost | Greedly Launcher of Small Tasks |
| googletest | Google’s framework for writing C++ tests on a variety of platforms |
| gprof | The GNU Profiler |
| gprof2dot | This is a Python script to convert the output from many profilers into a dot graph. |
| hpctoolkit | HPCToolkit is an integrated suite of tools for measurement and analysis of program performance on computers ranging from multicore desktop systems to the nation’s largest supercomputers. |
| hwloc | The Portable Hardware Locality (hwloc) software package provides a portable abstraction (across OS, versions, architectures, …) of the hierarchical topology of modern architectures, including NUMA memory nodes, sockets, shared caches, cores and simultaneous multithreading. It also gathers various system attributes such as cache and memory information. It primarily aims at helping applications with gathering information about modern computing hardware so as to exploit it accordingly and efficiently. |
| igprof | the Ignominous Profiler |
| inspector | Memory and thread debugger |
| intltool | intltool is a set of tools to centralize translation of many different file formats using GNU gettext-compatible PO files. |
| ipm | IPM is a portable profiling infrastructure for parallel codes. |
| itac | Intel Trace Analyzer and Collector |
| julia | high-level, high-performance dynamic programming language for technical computing |
| linaro-forge | C, C++ and F90 profiler and parallel Debugger for high performance and multithreaded Linux applications (DDT, MAP…) |
| makedepf90 | Makedepf90 is a program for automatic creation of Makefile-style dependency lists for Fortran source code. |
| matlab | MATLAB is a high-level language and interactive environment that enables you to perform computationally intensive tasks faster than with traditional programming languages such as C, C++, and Fortran. |
| memonit | Memonit is a tool developed by TGCC staff in order to monitor the memory consumption of a job during time |
| mercurial | Mercurial is a free, distributed source control management tool. It efficiently handles projects of any size and offers an easy and intuitive interface |
| mmg | Mmg is an open source software for simplicial remeshing. |
| mono | Cross platform, open source .NET framework |
| mpifileutils | mpiFileUtils provides both a library called libmfu and a suite of MPI-based tools to manage large datasets, which may vary from large directory trees to large files. |
| mplayer | MPlayer is a movie player which runs on many systems |
| myqlm | myQLM is a quantum software stack for writing, simulating, optimizing, and executing quantum programs. |
| n2p2 | If you have a working neural network potential setup (i.e. a settings file with network and symmetry function parameters, weight files and a scaling file) ready and want to predict energies and forces for a single structure you only need these components: |
| nco | The netCDF Operators (NCO) comprise command-line programs that take netCDF or HDF files as input, then operate and output the results to screen or files |
| nedit | NEdit is a fast, compact Motif/X11 plain text editor |
| ninja | A small build system with a focus on speed. |
| nsight-compute | NVIDIA Nsight Compute is an interactive kernel profiler for CUDA applications. |
| nsight-systems | NVIDIA Nsight Systems is a system-wide performance analysis tool designed to visualize an application’s algorithm |
| nsight | Nvidia profiler |
| octave | Octave is a high-level interpreted language, primarily intended for numerical computations |
| opari2 | OPARI2, the successor of Forschungszentrum Juelich’s OPARI,is a source-to-source instrumentation tool for OpenMP and hybrid codes. It surrounds OpenMP directives and runtime library calls with calls to the POMP2 measurement interface. |
| openstack | OpenStack is a set of software components that provide common services for cloud infrastructure. |
| otf2 | The Open Trace Format 2 is a highly scalable, memory efficient event trace data format plus support library. It will become the new standard trace format for Scalasca, Vampir, and Tau and is open for other tools |
| pandoc | Pandoc is a Haskell library for converting from one markup format to another, and a command-line tool that uses this library |
| papi | Performance Application Programming Interface |
| pdtoolkit | Program Database Toolkit (PDT) is a framework for analyzing source code written in several programming languages and for making rich program knowledge accessible to developers of static and dynamic analysis tools |
| perl | Perl 5 is a highly capable, feature-rich programming language with over 25 years of development. |
| pigz | Parallel implementation of gzip |
| pycharm | The Python IDE for Professional Developers |
| python3 | Python programming language |
| r | R programming language |
| readline | The GNU readline library allows users to edit command lines as they are typed in. It can maintain a searchable history of previously entered commands, letting you easily recall, edit and re-enter past commands. It features both Emacs-like and vi-like keybindings, making its usage comfortable for anyone |
| reframe | ReFrame is a powerful framework for writing system regression tests and benchmarks, specifically targeted to HPC systems. |
| root | The ROOT system provides a set of OO frameworks with all the functionality needed to handle and analyze large amounts of data in a very efficient way. |
| scalasca | Software tool for measuring and analyzing performances of parallel programs |
| scons | Open Source software construction tool |
| scorep | the Scalable Performance Measurement Infrastructure for Parallel Codes is a software system that provides a measurement infrastructure for profiling, event trace recording, and online analysis of HPC applications |
| smokeview | Smokeview is a visualization program that displays the output of fds |
| sqlite | SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. |
| subversion | Subversion is a concurrent version control system |
| swift | OpenStack is a set of software components that provide common services for cloud infrastructure. |
| swig | SWIG is an interface compiler that connects programs written in C and C++ with scripting languages such as Perl, Python, Ruby, and Tcl. |
| sz | SZ is a modular parametrizable lossy compressor framework for scientific data (floating point and integers). It has applications in simulations, AI and instruments. It is a production quality software and a research platform for lossy compression. SZ is open and transparent. Open because all interested researchers and students can study or contribute to it. Transparent because all performance improvements are detailed in publications. SZ can be used for classic use-cases: visualization, accelerating I/O, reducing memory and storage footprint and more advanced use-cases like compression of DNN models and training sets, acceleration of computation, checkpoint/restart, reducing streaming intensity and running efficiently large problems that cannot fit in memory. Other use-cases will augment this list as users find new opportunities to benefit from lossy compression of scientific data |
| tau | TAU (Tuning and Analysis Utilities) is a portable profiling and tracing toolkit for performance analysis of parallel programs written in Fortran, C, C++, UPC, Java, Python |
| texlive | TeX Live is an easy way to get up and running with the TeX document production system. |
| themys | ParaView’s branded application |
| tkcvs | A Tcl/Tk based graphical interface to the CVS and Subversion configuration management systems. Support for Git and RCS too. |
| totalview | Dynamic source code and memory debugging for C, C++ and Fortran applications. |
| udunits | The UDUnits package from Unidata is a C-based package for the programatic handling of units of physical quantities. |
| uprof | AMD uProf is a performance analysis tool for applications. It allows developers to better understand the runtime performance of their application and to identify ways to improve its performance. |
| uranie | Uranie is a sensitivity and uncertainty analysis plateform based on the ROOT framework (http://root.cern.ch) . It is developed at CEA, the French Atomic Energy Commission (http://www.cea.fr). |
| valgrind | Debugging and memory checking tools |
| vampir | Profiling tool for parallel programs |
| vampirserver | Profiling tool for parallel programs |
| vdt | A collection of fast and inline implementations of mathematical functions |
| vef | VEF-Prospector is an open-source package for profiling MPI application in order to generate VEF trace-files. The VEF traces can be read by the VEF-TraceLIB to feed any network simulator. |
| vtune | Performance profiler for serial and parallel performance analysis |
| xcrysden | XCrySDen is a crystalline and molecular structure visualisation program aiming at display of isosurfaces and contours, which can be superimposed on crystalline structures and interactively rotated and manipulated. |
| xmlto | apply an XSL stylesheet to an XML document |
Specific software
The center has specific rules for restricted products and purchased products.
Restricted software products
A restricted product is referenced by module, but its access is restricted to a specific Unix group. Although the reasons may vary, this usually comes from a license requirement.
For example, a licensed product may restrict its usage to academic purposes, or the purchased license is an academic one.
Warning
Please refer to internal technical documentation to get information about this subject.
Installation request and restricted products
Warning
Please refer to internal technical documentation to get information about this subject.
Products with purchased license
Some products (such as Intel compilers) require a license server. We refer to them as licensed products.
Module and licensed products
Here are several adaptations of module for licensed products:
- A licensed product module depends on a license module to find its license server.
- Although the license module is not shown at load time, a module list can display it.
- license module are named licsrv/<server> and are listed by:
module avail licsrv
Installation request and purchased products
While requesting the installation of a purchased product, you may:
- have a license not requiring a dedicated server,
- have the license and want to restrict its usage to a group of people (because you only have a few tokens),
- have a global license (limited in time),
- have no license and ask for the center to purchase it.
The two first cases are handled by defining it as a restricted product.
The last case must be clearly justified. If so, you must at least:
- estimate the number of user,
- specify its application domain,
- tell us if you need the academic or the commercial license,
- and tell us if you need a global license and/or how many tokens are necessary.
Please note that, even if such installation follows the usual validation process, you may have additional delays, namely:
- if you need a non-FlexNet dedicated license server,
- if you need to generate some license server identification (done by us and filtered for security reasons) before getting the license.