Attention une mise à jour du serveur va être effectuée le vendredi 16 avril entre 12h et 12h30. Cette mise à jour va générer une interruption du service de quelques minutes.

Commit 6c900181 authored by PRUVOST Florent's avatar PRUVOST Florent

Merge branch 'users_doc' into 'master'

Users doc

See merge request !62
parents 63807de3 e178e704
......@@ -32,3 +32,12 @@ quark:
- cmake .. -DCHAMELEON_SCHED_QUARK=ON
- make -j2
- ctest -V -R test_shm_s
doc:
script:
- source .gitlab-ci-env.sh
- git submodule update --init --recursive
- mkdir -p build
- cd build
- cmake .. -DCHAMELEON_ENABLE_DOC=ON -DCHAMELEON_ENABLE_EXAMPLES=OFF -DCHAMELEON_ENABLE_TESTING=OFF -DCHAMELEON_ENABLE_TIMING=OFF
- make
......@@ -37,9 +37,9 @@ if("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}")
endif()
# set project version number
set(CHAMELEON_VERSION_MAJOR 0)
set(CHAMELEON_VERSION_MINOR 9)
set(CHAMELEON_VERSION_MICRO 1)
set(CHAMELEON_VERSION_MAJOR 1)
set(CHAMELEON_VERSION_MINOR 0)
set(CHAMELEON_VERSION_MICRO 0)
set(MORSE_CMAKE_DIR "" CACHE PATH "Directory of MORSE CMake modules, can be external to the project")
......@@ -205,9 +205,9 @@ endif()
# Options to enable/disable testings and timings
# ----------------------------------------------
option(CHAMELEON_ENABLE_DOCS "Enable documentation build" OFF)
if (CHAMELEON_ENABLE_DOCS)
message("-- ${BoldGreen}CHAMELEON_ENABLE_DOCS is set to ON, turn it OFF to avoid building docs${ColourReset}")
option(CHAMELEON_ENABLE_DOC "Enable documentation build" OFF)
if (CHAMELEON_ENABLE_DOC)
message("-- ${BoldGreen}CHAMELEON_ENABLE_DOC is set to ON, turn it OFF to avoid building docs${ColourReset}")
endif()
option(CHAMELEON_ENABLE_EXAMPLE "Enable examples build" ON)
if (CHAMELEON_ENABLE_EXAMPLE)
......@@ -1084,10 +1084,10 @@ endif(CHAMELEON_ENABLE_TIMING)
# Documentation #
#################
if(CHAMELEON_ENABLE_DOCS)
add_subdirectory(docs)
if (DOXYGEN_EXECUTABLE AND MAKEINFO_COMPILER AND TEXI2DVI_COMPILER AND TEX_COMPILER)
add_custom_target(docs ALL DEPENDS doxygen-out doc-info-users_guide doc-html-users_guide doc-pdf-users_guide)
if(CHAMELEON_ENABLE_DOC)
add_subdirectory(doc)
if (DOXYGEN_EXECUTABLE AND EMACS_COMPILER AND TEX_COMPILER)
add_custom_target(doc ALL DEPENDS doxygen-out doc-html-users_guide doc-pdf-users_guide)
endif()
endif()
#------------------------------------------------------------------------------
......
......@@ -6,6 +6,7 @@ chameleon-1.0.0
- Add First stage algorithm fo r the SVD/EVD solvers
- add timing drivers time_zpotrs_tile and time_zgeqrs_tile
- deactivate warmup by default
- add an orgmode user guide documentation, see in doc/orgmode/
chameleon-0.9.1
------------------------------------------------------------------------
......
****************************************************
Some instructions about CHAMELEON installation
****************************************************
This is a brief discussion about CHAMELEON usage.
For more information, please read the document users_guide.
Compilation of CHAMELEON libraries and executables are done with CMake
(http://www.cmake.org/). This version has been tested with CMake 2.8.8.
Usage: three steps are required to compile and install CHAMELEON
1) configure :
> cmake path/to/chameleon -DOPTION1= -DOPTION2= ...
see the "Options" section to get list of options
see the "Dependencies detection" for details about libraries detection
2) build :
> make
do not hesitate to use -j[ncores] option to speedup the compilation
3) install (optional) :
> make install
do not forget to specify the install directory with -DCMAKE_INSTALL_PREFIX at configure
example : cmake /home/toto/chameleon -DCMAKE_INSTALL_PREFIX=/home/toto/install
-------------------------------------------
* List of libraries CHAMELEON depends on *
-------------------------------------------
threads : pthread
blas : netlib, openblas, eigen or intel mkl
cblas : netlib, openblas or intel mkl
lapack : netlib, openblas, eigen or intel mkl
lapacke : netlib, openblas or intel mkl
tmg : netlib, openblas or intel mkl
runtime : quark (http://icl.cs.utk.edu/quark/) or
starpu (http://runtime.bordeaux.inria.fr/StarPU/)
hwloc : (http://www.open-mpi.org/projects/hwloc/)
optional libraries
cuda : (https://developer.nvidia.com/cuda-downloads)
cublas : comes with cuda (http://docs.nvidia.com/cuda/cublas/)
mpi : openmpi (http://www.open-mpi.org/)
FxT : linux package (libfxt) or releases here http://download.savannah.gnu.org/releases/fkt/
These packages must be installed on the system before trying to configure/build chameleon.
Please look at the distrib/ directory which gives some hints for the installation of dependencies for Unix systems.
-----------------------------------------
-------------------------------------------
* Dependencies detection *
-------------------------------------------
You have different choices to detect dependencies on your system, either by
setting some environment variables containing paths to the libs and headers or
by specifying them directly at cmake configure. Different cases :
1) detection of dependencies through environment variables:
- LD_LIBRARY_PATH should contain the list of paths where to find the libraries:
* export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:install/path/to/your/lib
- INCLUDE should contain the list of paths where to find the header files of libraries
* export INCLUDE=$INCLUDE:install/path/to/your/headers
2) detection with user's given paths:
- you can specify the path at cmake configure by invoking
cmake path/to/your/CMakeLists.txt -DLIB_DIR=path/to/your/lib
where LIB stands for the name of the lib to look for
* example: cmake path/to/your/CMakeLists.txt -DSTARPU_DIR=path/to/starpudir \
-DCBLAS_DIR= ...
it is also possible to specify headers and library directories separately
* example: cmake path/to/your/CMakeLists.txt -DSTARPU_INCDIR=path/to/libstarpu/include/starpu/1.1 \
-DSTARPU_LIBDIR=path/to/libstarpu/lib
- note: BLAS and LAPACK detection can be tedious so that we provide a verbose mode
you can set -DBLAS_VERBOSE=ON or -DLAPACK_VERBOSE=ON to activate it
-------------------------------------------
* Options *
-------------------------------------------
You can optionally activate some options at cmake configure (like CUDA, MPI, ...)
invoking cmake path/to/your/CMakeLists.txt -DOPTION1= -DOPTION2= ...
example: cmake /home/toto/chameleon/ -DCMAKE_BUILD_TYPE=Debug \
-DCMAKE_INSTALL_PREFIX=/home/toto/install/ \
-DCHAMELEON_USE_CUDA=ON \
-DCHAMELEON_USE_MPI=ON \
-DBLA_VENDOR=Intel10_64lp \
-DSTARPU_DIR=/home/toto/install/starpu-1.1/build/include/starpu/1.1/ \
-DCHAMELEON_ENABLE_TRACING=ON
You can get the full list of options with -L[A][H] options of cmake command
example: cmake -LH /home/toto/chameleon/
You can also set the options thanks to ccmake interface
Some options (non-exhaustive list) :
------------------------------------
Basic CMake:
------------
CMAKE_BUILD_TYPE=Debug|Release
CMAKE_INSTALL_PREFIX=path/to/your/install/dir (where headers and libraries will be copied
when invoking make install)
Related to specific modules (find_package):
------------------------------------------
BLA_VENDOR=Intel10_64lp (to use intel mkl for example, see the list of BLA_VENDOR in FindBLAS.cmake in cmake_modules/morse/find)
# for the following, see section "Dependencies detection"
STARPU_DIR=...
STARPU_INCDIR=...
STARPU_LIBDIR=...
# same idea can be used for some packages, replace STARPU by one of these:
BLAS - CBLAS - FXT - HWLOC - LAPACK - LAPACKE - QUARK - TMG
CHAMELEON specific:
--------------------
CHAMELEON_USE_MPI=ON|OFF (default OFF)
CHAMELEON_USE_CUDA=ON|OFF (default OFF)
CHAMELEON_ENABLE_TRACING=ON|OFF (default OFF)
CHAMELEON_SCHED_STARPU=ON|OFF (default ON)
CHAMELEON_SCHED_QUARK=ON|OFF (default OFF)
CHAMELEON_SIMULATION=ON|OFF (default OFF)
Libraries detected with an official cmake module (see module files in CMAKE_ROOT/Modules/):
CUDA - MPI - Threads
Libraries detected with our cmake modules (see module files in cmake_modules/morse/find/ directory of CHAMELEON sources):
BLAS - CBLAS - FXT - HWLOC - LAPACK - LAPACKE - QUARK - STARPU - TMG
-------------------------------------------
* Use FxT profiling through StarPU *
-------------------------------------------
StarPU can generate its own trace log files by compiling it with the --with-fxt
option at the configure step (you can have to specify the directory where you
installed FxT by giving --with-fxt=... instead of --with-fxt alone).
By doing so, traces are generated after each execution of a program which uses
StarPU in the directory pointed by the STARPU_FXT_PREFIX environment variable.
example: export STARPU_FXT_PREFIX=/home/toto/fxt_files/
When executing a ./timing/... CHAMELEON program, if it has been enabled
(StarPU compiled with FxT and -DCHAMELEON_ENABLE_TRACING=ON), you can give the option --trace
to tell the program to generate trace log files.
Finally, to generate the trace file which can be opened with Vite program
(http://vite.gforge.inria.fr/), you have to use the starpu_fxt_tool tool of StarPU.
This tool should be in $STARPU_INSTALL_REPOSITORY/bin.
You can use it to generate the trace file like this:
> path/to/your/install/starpu/bin/starpu_fxt_tool -i prof_filename
There is one file per mpi processus (prof_filename_0, prof_filename_1 ...).
To generate a trace of mpi programs you can call it like this:
> path/to/your/install/starpu/bin/starpu_fxt_tool -i prof_filename*
The trace file will be named paje.trace (use -o option to specify an output name).
-------------------------------------------
* Use simulation mode with StarPU-SimGrid *
-------------------------------------------
Simulation mode can be activated by setting the cmake option CHAMELEON_SIMULATION to ON.
This mode allows you to simulate execution of algorithms with StarPU compiled with SimGrid (http://simgrid.gforge.inria.fr/).
To do so, we provide some perfmodels in the simucore/perfmodels/ directory of CHAMELEON sources.
To use these perfmodels, please set your STARPU_HOME environment variable to path/to/your/chameleon_sources/simucore/perfmodels.
Finally, you need to set your STARPU_HOSTNAME environment variable to the name of the machine to simulate.
For example: STARPU_HOSTNAME=mirage.
Note that only POTRF kernels with block sizes of 320 or 960 (simple and double precision) on mirage machine are available for now.
Database of models is subject to change, it should be enrich in a near future.
......@@ -43,50 +43,37 @@ dedicated to dense linear algebra.
now. Future releases will be available on this gitlab project.
* Documentation
There is no up-to-date documentation of Chameleon. We would like to
provide a doxygen documentation hosted on [[https://about.gitlab.com/2016/04/07/gitlab-pages-setup/][gitlab]] in the
future. Please refer to the section 2.1 of [[file:READMEDEV.org][READMEDEV]] to get
information about the documentation generation.
The documentation of Chameleon's last release is available here:
[[http://morse.gforge.inria.fr/chameleon/0.9.1/chameleon_users_guide-0.9.1.html][chameleon-0.9.1 documentation]].
** User guide
The user guide is available directly in the sources as emacs
orgmode files, see :
1) [[file:doc/orgmode/chapters/introduction.org][Introduction]] : description of the scientific context
2) [[file:doc/orgmode/chapters/installing.org][Installing]] :
* Getting Chameleon
* Prerequisites for installing Chameleon
* Distribution of Chameleon using Spack
* Build and install Chameleon with CMake
3) [[file:doc/orgmode/chapters/using.org][Using]] :
* Linking an external application with Chameleon libraries
* Using Chameleon executables
* Chameleon API
This documentation could also be generated in html and/or pdf :
#+begin_src
# build the doc with cmake (emacs with orgmode and latex are required), e.g.
cmake .. -DCHAMELEON_ENABLE_DOC=ON
make doc
#+end_src
** Source code documentation (doxygen)
There is no up-to-date documentation of Chameleon. We would like to
provide a doxygen documentation hosted on [[https://about.gitlab.com/2016/04/07/gitlab-pages-setup/][gitlab]] in the
future. Please refer to the section 2.1 of [[file:READMEDEV.org][READMEDEV]] to get
information about the documentation generation.
** For developers
[[file:READMEDEV.org][READMEDEV]]
* Installation
** Distribution of Chameleon
To get support to install a full distribution (Chameleon +
dependencies) we encourage users to use the morse branch of *Spack*.
Please read these documentations:
* [[http://morse.gforge.inria.fr/spack/spack.html][Spack Morse]]
* [[http://morse.gforge.inria.fr/spack/spack.html#sec-2-1][Section Chameleon]]
*** Usage example for a simple distribution of Chameleon
#+begin_src sh
git clone https://github.com/solverstack/spack.git
. ./spack/share/spack/setup-env.sh
spack install -v chameleon
# chameleon is installed here:
`spack location -i chameleon`
#+end_src
** Build and install with CMake
Chameleon can be built using [[https://cmake.org/][CMake]]. This installation requires to
have some library dependencies already installed on the system.
Please refer to [[http://morse.gforge.inria.fr/chameleon/0.9.1/chameleon_users_guide-0.9.1.html#Installing-CHAMELEON][chameleon-0.9.1]] to get configuration information.
Please refer to the [[file:READMEDEV.org][READMEDEV]] page.
* Get involved!
** Mailing list
To contact the developers send an email to
......
......@@ -28,7 +28,6 @@ developers must follow and that should be read by contributors.
* Documentation
<<sec:doc>>
** Generate the documentation
*** Prerequisites
To generate the documentation you need to have [[http://www.stack.nl/~dimitri/doxygen/][Doxygen]] and
......@@ -36,25 +35,25 @@ developers must follow and that should be read by contributors.
For example, on Debian systems:
#+begin_src sh
sudo apt install doxygen texinfo
sudo apt install doxygen texinfo texlive texlive-latex-extra emacs
#+end_src
*** configure + make documentation
Enter into the Chameleon's source root directory and configure
with *CHAMELEON_ENABLE_DOCS=ON*, then generate the documentation
with ~make docs~
with *CHAMELEON_ENABLE_DOC=ON*, then generate the documentation
with ~make doc~
#+begin_src sh
cd chameleon
mkdir build && cd build
cmake .. -DCHAMELEON_ENABLE_DOCS=ON
make docs
cmake .. -DCHAMELEON_ENABLE_DOC=ON
make doc
#+end_src
** Rules about source code documentation
Please refer to this file for the documentation guidelines [[file:docs/doxygen/README.org][README]].
Please refer to this file for the documentation guidelines [[file:doc/doxygen/README.org][README]].
* Naming and writting conventions
......@@ -83,8 +82,10 @@ developers must follow and that should be read by contributors.
#+begin_src sh
export CHAMELEON_ROOT=/path/to/chameleon/sources/to/be/released
cmake $CHAMELEON_ROOT -DCHAMELEON_ENABLE_DOCS=ON
make docs && cp docs/texinfo/users_guide.pdf $CHAMELEON_ROOT && make package_source
cmake $CHAMELEON_ROOT -DCHAMELEON_ENABLE_DOC=ON
make doc
cp doc/orgmode/users_guide.pdf $CHAMELEON_ROOT
make package_source
#+end_src
A tarball chameleon-major.minor.patch.tar.gz should be generated
......
......@@ -58,7 +58,7 @@ set(dep_message "${dep_message}"
" Simulation mode .....: ${CHAMELEON_SIMULATION}\n"
"\n"
" Binaries to build\n"
" documentation ........: ${CHAMELEON_ENABLE_DOCS}\n"
" documentation ........: ${CHAMELEON_ENABLE_DOC}\n"
" example ..............: ${CHAMELEON_ENABLE_EXAMPLE}\n"
" testing ..............: ${CHAMELEON_ENABLE_TESTING}\n"
" timing ...............: ${CHAMELEON_ENABLE_TIMING}\n"
......
......@@ -3,7 +3,7 @@
# @copyright (c) 2009-2014 The University of Tennessee and The University
# of Tennessee Research Foundation.
# All rights reserved.
# @copyright (c) 2012-2014 Inria. All rights reserved.
# @copyright (c) 2012-2017 Inria. All rights reserved.
# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
#
###
......@@ -22,6 +22,7 @@
# @author Cedric Castagnede
# @author Emmanuel Agullo
# @author Mathieu Faverge
# @author Florent Pruvost
# @date 13-07-2012
#
###
......@@ -34,8 +35,8 @@ cmake_minimum_required(VERSION 2.8)
# #
#############################################
add_subdirectory(doxygen)
add_subdirectory(texinfo)
add_subdirectory(orgmode)
#add_subdirectory(texinfo)
###
### END CMakeLists.txt
###
......@@ -77,6 +77,7 @@ if(DOXYGEN_EXECUTABLE)
add_custom_target(doxygen-out ALL
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/out-dev
#${CMAKE_CURRENT_BINARY_DIR}/out-usr
chameleon
)
# Installation for html version
......
###
#
# @copyright (c) 2017 Inria. All rights reserved.
#
###
#
# @file CMakeLists.txt
#
# @project MORSE
# MORSE is a software package provided by:
# Inria Bordeaux - Sud-Ouest,
# Univ. of Tennessee,
# King Abdullah Univesity of Science and Technology
# Univ. of California Berkeley,
# Univ. of Colorado Denver.
#
# @version 1.0.0
# @author Florent Pruvost
# @date 25-08-2017
#
###
cmake_minimum_required(VERSION 2.8)
# Create file version.org
# -----------------------
configure_file("version.org.in"
"version.org"
@ONLY)
configure_file("users_guide.org.in"
"users_guide.org"
@ONLY)
set(FIGURES
tile_lu.pdf
tile_lu.jpg
tile_layout.pdf
tile_layout.jpg
trace_qr.pdf
trace_qr.jpg
potri_async.png
morse_header.png
)
set(FIGURES_HTML
tile_lu.jpg
tile_layout.jpg
trace_qr.jpg
potri_async.png
morse_header.png
)
foreach(_fig ${FIGURES})
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/chapters/${_fig}
${CMAKE_CURRENT_BINARY_DIR}/${_fig}
COPYONLY)
endforeach()
# Looking for emacs
# -----------------
FIND_PROGRAM(EMACS_COMPILER emacs)
FIND_PROGRAM(TEX_COMPILER tex)
if(EMACS_COMPILER)
# Add target
# ----------
add_custom_command(OUTPUT users_guide.html
COMMAND ${EMACS_COMPILER}
ARGS ${CMAKE_CURRENT_BINARY_DIR}/users_guide.org
--batch
-f
org-html-export-to-html
--kill
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/users_guide.org
${CMAKE_CURRENT_BINARY_DIR}/version.org
)
add_custom_command(OUTPUT users_guide.pdf
COMMAND ${EMACS_COMPILER}
ARGS ${CMAKE_CURRENT_BINARY_DIR}/users_guide.org
--batch
-f
org-latex-export-to-pdf
--kill
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/users_guide.org
${CMAKE_CURRENT_BINARY_DIR}/version.org
)
add_custom_target(doc-html-users_guide ALL DEPENDS users_guide.html chameleon)
add_custom_target(doc-pdf-users_guide ALL DEPENDS users_guide.pdf chameleon)
# Installation
# ------------
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/users_guide.html
DESTINATION share/chameleon/html)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/users_guide.pdf
DESTINATION share/chameleon/pdf)
foreach(_fig ${FIGURES_HTML})
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_fig}
DESTINATION share/chameleon/html)
endforeach()
else(EMACS_COMPILER)
message(STATUS "Looking for emacs - not found")
endif(EMACS_COMPILER)
###
### END CMakeLists.txt
###
This diff is collapsed.
# This file is part of the Chameleon User's Guide.
# Copyright (C) 2017 Inria
# See the file ../users_guide.org for copying conditions.
** MORSE project
#+NAME: fig:morse_header
#+ATTR_HTML: :align center
[[file:morse_header.png]]
Chameleon is a linear algebra software created jointly by several
research teams as part of the MORSE associate team: [[http://www.icl.utk.edu/][ICL]], [[https://www.inria.fr/en/][Inria]],
[[https://www.kaust.edu.sa/en][KAUST]], [[http://www.ucdenver.edu/pages/ucdwelcomepage.aspx][The University of Colorado Denver]].
*** MORSE Objectives
When processor clock speeds flatlined in 2004, after more than
fifteen years of exponential increases, the era of near automatic
performance improvements that the HPC application community had
previously enjoyed came to an abrupt end. To develop software that
will perform well on petascale and exascale systems with thousands
of nodes and millions of cores, the list of major challenges that
must now be confronted is formidable:
1) dramatic escalation in the costs of intrasystem communication
between processors and/or levels of memory hierarchy;
2) increased heterogeneity of the processing units (mixing CPUs,
GPUs, etc. in varying and unexpected design combinations);
3) high levels of parallelism and more complex constraints means
that cooperating processes must be dynamically and unpredictably
scheduled for asynchronous execution;
4) software will not run at scale without much better resilience to
faults and far more robustness; and
5) new levels of self-adaptivity will be required to enable
software to modulate process speed in order to satisfy limited
energy budgets.
The MORSE associate team will tackle the first three challenges in
a orchestrating work between research groups respectively
specialized in sparse linear algebra, dense linear algebra and
runtime systems. The overall objective is to develop robust linear
algebra libraries relying on innovative runtime systems that can
fully benefit from the potential of those future large-scale
complex machines. Challenges 4) and 5) will also be investigated
by the different teams in the context of other partnerships, but
they will not be the main focus of the associate team as they are
much more prospective.
*** Research fields
The overall goal of the MORSE associate team is to enable advanced
numerical algorithms to be executed on a scalable unified runtime
system for exploiting the full potential of future exascale
machines. We expect advances in three directions based first on
strong and closed interactions between the runtime and numerical
linear algebra communities. This initial activity will then
naturally expand to more focused but still joint research in both
fields.
**** Fine interaction between linear algebra and runtime systems
On parallel machines, HPC applications need to take care of data
movement and consistency, which can be either explicitly managed
at the level of the application itself or delegated to a runtime
system. We adopt the latter approach in order to better keep up
with hardware trends whose complexity is growing exponentially.
One major task in this project is to define a proper interface
between HPC applications and runtime systems in order to maximize
productivity and expressivity. As mentioned in the next section,
a widely used approach consists in abstracting the application as
a DAG that the runtime system is in charge of scheduling.
Scheduling such a DAG over a set of heterogeneous processing units
introduces a lot of new challenges, such as predicting accurately
the execution time of each type of task over each kind of unit,
minimizing data transfers between memory banks, performing data
prefetching, etc. Expected advances: In a nutshell, a new runtime
system API will be designed to allow applications to provide
scheduling hints to the runtime system and to get real-time
feedback about the consequences of scheduling decisions.
**** Runtime systems
A runtime environment is an intermediate layer between the system
and the application. It provides low-level functionality not
provided by the system (such as scheduling or management of the
heterogeneity) and high-level features (such as performance
portability). In the framework of this proposal, we will work on
the scalability of runtime environment. To achieve scalability it
is required to avoid all centralization. Here, the main problem
is the scheduling of the tasks. In many task-based runtime
environments the scheduler is centralized and becomes a bottleneck
as soon as too many cores are involved. It is therefore required
to distribute the scheduling decision or to compute a data
distribution that impose the mapping of task using, for instance
the so-called ``owner-compute'' rule. Expected advances: We will
design runtime systems that enable an efficient and scalable use
of thousands of distributed multicore nodes enhanced with
accelerators.
**** Linear algebra