Source originale : Wikipedia

Trilinos is a collection of open source software libraries, called packages, intended to be used as building blocks for the development of scientific applications. This library was developed at Sandia National Laboratories from a core group of existing algorithms, and utilizes the functionality of well-known packages such as BLAS and LAPACK.

Trilinos contains packages for:

• Constructing and using sparse and dense matrices, graphs and vectors.
• Iterative and direct solution of linear systems.
• Parallel multilevel and algebraic preconditioning.
• Solution of non-linear, eigenvalue and time-dependent problems.
• PDE-constrained optimization problem.
• Partitioning and load balancing of distributed data structures.
• Automatic differentiation.
• PDE-discretizations.

Most Trilinos packages are written in C++ with Fortran kernels used for performance-sensitive computations. Python bindings are provided using SWIG.

Liste de tous les packages disponibles

Liste des packages installés au mésocentre

Anasazi, CTrilinos, Fei, Ifpack, Kokkos, Moertel, Optipack, Pliris, Sacado, Stratimikos, ThreadPool, Trilinoscouplings Aztecoo, Didasko, ForTrilinos, Ifpack2, Komplex, Moocho, Pamgen, PyTrilinos, Shards, Sundance, Thyra, Belos, Epetra, Galeri, Intrepid, Mesquite, Nox, Phalanx, Rtop, Stk, Teko, Tpetra, Triutils

Trois versions de cette bibliothèque sont disponibles :

1. Version séquentielle compilée avec le compilateur gcc et utilisant les versions standards de blas et de lapack
2. Version séquentielle compilée avec le compilateur Intel (icc, icpc) utilisant MKL pour blas et lapack
3. Version parallèle compilée avec Open MPI et utilisant les versions standards de blas et de lapack

Chacune de ces variantes est associée à son propre module sur le cluster, qu'il est possible de charger pour utiliser automatiquement cette version :

 [kmazouzi@mesocomte0 ~]$ module avail trilinos
 
 trilinos/serial/gcc/10.4.0 
 
 trilinos/serial/icc/10.4.0 
 
 trilinos/parallel/ompi/10.4.0

Par exemple pour utiliser la version Intel/MLK :

module  load trilinos/serial/icc/10.4.0 

EpetraSimpleVector.cpp

#include "Epetra_SerialComm.h"
#include "Epetra_Map.h"
#include "Epetra_Vector.h"
#include "Epetra_Version.h"
 
int main(int argc, char *argv[])
{
 
  cout << Epetra_Version() << endl << endl;
 
  Epetra_SerialComm Comm;
 
  int NumElements = 1000;
 
  // Construct a Map with NumElements and index base of 0
  Epetra_Map Map(NumElements, 0, Comm);
 
  // Create x and b vectors
  Epetra_Vector x(Map);
  Epetra_Vector b(Map);
 
  b.Random();
 
  x.Update(2.0, b, 0.0); // x = 2*b
 
  double bnorm, xnorm;
 
  x.Norm2(&xnorm);
  b.Norm2(&bnorm);
 
  cout << "2 norm of x = " << xnorm << endl
       << "2 norm of b = " << bnorm << endl;
 
  return 0;
}

GaleriLinearSystem.cpp

#include "Galeri_Maps.h"
#include "Galeri_CrsMatrices.h"
#include "Galeri_Utils.h"
#ifdef HAVE_MPI
#include "Epetra_MpiComm.h"
#include "mpi.h"
#else
#include "Epetra_SerialComm.h"
#endif
#include "Epetra_Map.h"
#include "Epetra_CrsMatrix.h"
#include "Teuchos_ParameterList.hpp"
#include "Teuchos_RCP.hpp"
 
using namespace Galeri;
 
// =========== //
// main driver //
// =========== //
 
int main(int argv, char* argc[])
{
  using Teuchos::RCP;
  using Teuchos::rcp;
 
#ifdef HAVE_MPI
  MPI_Init (&argv, &argc);
  Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
  Epetra_SerialComm Comm;
#endif
 
  // Create a parameter list
  Teuchos::ParameterList GaleriList;
 
  // Set the number of discretization points in the x and y direction.
  GaleriList.set ("nx", 10 * Comm.NumProc ());
  GaleriList.set ("ny", 10);
 
  // Create the map and matrix using the parameter list for a 2D Laplacian.
  RCP<Epetra_Map> Map = rcp (CreateMap ("Cartesian2D", Comm, GaleriList));
  RCP<Epetra_CrsMatrix> Matrix = rcp (CreateCrsMatrix ("Laplace2D", &*Map, GaleriList));
 
  // Print out the map and matrices  
  Map->Print (std::cout);
  Matrix->Print (std::cout);
 
#ifdef HAVE_MPI
  MPI_Finalize ();
#endif
  return 0;
}

Trilinos fournit des fichiers Makefile prédifinis dans le répertoire d'instalation $(TRILINOS_DIR)/include, permettant de compiler/linker les applications en utilisant le même compilateur et les mêmes options de compilation que celles utilisés pour l'installation des packages.

Pour compiler vos applications, il suffit donc créer un nouveau makefile et d'importer le makefile correspondant aux packages utilisés.

Voici en exemple d'un makefile permettant de compiler le programme Vect.cpp décrit ci-dessus :

Makefile

include $(TRILINOS_DIR)/include/Makefile.export.Trilinos
 
# Make sure to use same compilers and flags as Trilinos
CXX=$(Trilinos_CXX_COMPILER)
CC=$(Trilinos_C_COMPILER)
FORT=$(Trilinos_Fortran_COMPILER)
 
CXX_FLAGS=$(Trilinos_CXX_COMPILER_FLAGS) $(USER_CXX_FLAGS)
C_FLAGS=$(Trilinos_C_COMPILER_FLAGS) $(USERC_FLAGS)
FORT_FLAGS=$(Trilinos_Fortran_COMPILER_FLAGS) $(USER_FORT_FLAGS)
 
INCLUDE_DIRS=$(Trilinos_INCLUDE_DIRS) $(Trilinos_TPL_INCLUDE_DIRS)
LIBRARY_DIRS=$(Trilinos_LIBRARY_DIRS) $(Trilinos_TPL_LIBRARY_DIRS)
LIBRARIES=$(Trilinos_LIBRARIES) 
 
LINK_FLAGS=$(Trilinos_EXTRA_LD_FLAGS)
 
#just assuming that epetra is turned on.
DEFINES=-DMYAPP_EPETRA
 
 
# build the 
MyApp.exe: Vect.o
        $(CXX) $(CXX_FLAGS)  Vect.cpp -o  MyApp.exe $(LINK_FLAGS)  $(INCLUDE_DIRS)  $(DEFINES)  $(LIBRARY_DIRS)  $(LIBRARIES)
 
 
Vect.o:
        $(CXX) -c $(CXX_FLAGS) $(INCLUDE_DIRS) $(DEFINES) Vect.cpp
 
.PHONY: clean
clean:
        rm -f *.o *.a *.exe 

$make

$ ./MyApp.exe 
Epetra in Trilinos 10.6.4
 
2 norm of x = 35.8368
2 norm of b = 17.9184

Pour exécuter notre application, on utilisera typiquement mpirun :

mpirun -np 4 MyAppli.exe
 
 
Number of Global Elements  = 400
Number of Global Points    = 400
Maximum of all GIDs        = 399
Minimum of all GIDs        = 0
Index Base                 = 0
Constant Element Size      = 1
 
Number of Local Elements   = 100
Number of Local Points     = 100
Maximum of my GIDs         = 179
Minimum of my GIDs         = 0
 
         MyPID           Local Index        Global Index  
             0                 0                 0    
             0                 1                40    
             0                 2                80    
             0                 3               120    
             0                 4               160

Il semble que le support de Fortran n'est pas totalement finalisé. L'objectif du projet ForTrilinos est de fournir des interfaces standards à tous les packages Trilinos.

• Une série de documents complets sur l'utilisation de trilinos Site officiel
• Quelques examples en C++ Lien externe
• Tutorial DIDASKO (Exemple de plusieurs packages) Site