update recommended version to 12.10.2018
[dealii.wiki.git] / deal.II-in-Spack.md
1 Table of Contents
2 =================
3
4    * [Using deal.II on Mac OS X and Linux via Spack](#using-dealii-on-mac-os-x-and-linux-via-spack)
5       * [Quick installation on the desktop](#quick-installation-on-the-desktop)
6       * [Installation example on a Centos7 cluster (Emmy cluster of RRZE, Erlangen, Germany)](#installation-example-on-a-centos7-cluster-emmy-cluster-of-rrze-erlangen-germany)
7       * [Enabling CUDA](#enabling-cuda)
8       * [Environment Modules](#environment-modules)
9       * [System provided packages](#system-provided-packages)
10       * [Installing GCC](#installing-gcc)
11       * [Best practices using Spack:](#best-practices-using-spack)
12          * [Info:](#info)
13          * [Extra options:](#extra-options)
14          * [Compiler flags](#compiler-flags)
15          * [Different versions coexisting:](#different-versions-coexisting)
16          * [Filesystem Views:](#filesystem-views)
17          * [Check before build:](#check-before-build)
18          * [Develop using Spack](#develop-using-spack)
19          * [Keep the stage to run unit tests](#keep-the-stage-to-run-unit-tests)
20          * [MKL and Licensed software](#mkl-and-licensed-software)
21          * [Freeze package versions](#freeze-package-versions)
22       * [Known issues using Spack:](#known-issues-using-spack)
23
24 # Using deal.II on Mac OS X and Linux via Spack
25
26 The deal.II suite is also available on Spack (https://github.com/LLNL/spack) -- a flexible package manager developed with High-Performance-Computing in mind. It is intended to let you build for many combinations of compiler, architectures, dependency libraries, and build configurations, all with a friendly, intuitive user interface.
27
28 For a quick overview of Spack's features, we recommend this short presentation https://tgamblin.github.io/files/Gamblin-Spack-SC15-Talk.pdf
29 or the following videos from lead developers:
30 [Massimiliano Culpo - SPACK: A Package Manager for Supercomputers, Linux and MacOS](https://www.youtube.com/watch?v=Qok-nXfIWfg) and 
31 [Todd Gamblin (LLNL) - Managing HPC Software Complexity with Spack](https://www.youtube.com/watch?v=Ie1cZTR09kk).
32
33 [Spack tutorial 101](http://spack.readthedocs.io/en/latest/tutorial.html) is good place to start as well.
34
35 Note: Spack is in active development and is in alpha state, thereby below we recommend using the specific snapshot of the code (hash), that was tested on macOS / Ubuntu / CentOS7 with deal.II and is being used to run the complete testsuite on `Unbutu18.04` with `openmpi` and `openblas`. See [Continuous section of CDash](https://cdash.kyomu.43-1.org/index.php?project=deal.II).
36
37 ## Quick installation on the desktop
38
39 Add the following to `~/.bashrc` (or equivalent)
40 ```
41 export SPACK_ROOT=/path/to/spack
42 export PATH="$SPACK_ROOT/bin:$PATH"
43 ```
44 `SPACK_ROOT` is the destination where you want Spack to be installed (i.e. `$HOME/spack`).
45
46 Now clone Spack
47 ```
48 cd $SPACK_ROOT
49 git clone https://github.com/spack/spack.git .
50 git checkout develop
51 git reset --hard e38f39e4eafeaa6daed580cece935141e5d8f04b
52 ```
53 The last command will reset Spack to the version dated 12.10.2018.
54
55 **Make sure C/C++/Fortran compilers are in path** (on Ubuntu you need to `sudo apt-get install gfortran`, on macOS you can compile `gcc` with spack, see [below](#installing-gcc), and you have **curl** (`sudo apt-get install curl`) to download packages. Then install the complete deal.II suite
56 ```
57 spack install --test=root dealii
58 ```
59 **DONE**! No extra (preliminary) configuration steps are needed on most Linux distributions. **IMPORTANT:** If you compile deal.II on a cluster, see the next section on how to use externally provided MPI implementation instead.
60 Additional option `--test=root` instructs Spack to run quick tests for `dealii`.
61
62 Before configuring your project you need to set `DEAL_II_DIR` by 
63 ```
64 export DEAL_II_DIR=$(spack location -i dealii)
65 ```
66 You may jump ahead and read [best practices using spack](#best-practices-using-spack). Also a good starting point is [Getting Started Guide](http://spack.readthedocs.io/en/latest/getting_started.html).
67
68
69 ## Installation example on a Centos7 cluster (Emmy cluster of RRZE, Erlangen, Germany)
70 In order to use Spack on a cluster, there are two options: (1) you are a sysadmin and you know hardware details and can use Spack to properly configure and build MPI providers (e.g. `openmpi`); (2) you are a user and you need to make Spack work with MPI provided on your cluster. Below we consider the latter case.
71
72 Here is a brief step-by-step instruction to install deal.II on [Emmy cluster](https://www.rrze.fau.de/dienste/arbeiten-rechnen/hpc/systeme/emmy-cluster.shtml#access) of RRZE, Erlangen, Germany:
73
74 (1) Download spack
75 ```
76 mkdir $WOODYHOME/spack
77 cd $WOODYHOME/spack
78 module load git
79 ```
80 (1a) If you plan on using `GCC/Clang` as a compiler:
81 ```
82 # Clone standard version of Spack
83 git clone https://github.com/llnl/spack.git $WOODYHOME/spack
84 export PATH=$WOODYHOME/spack/bin:$PATH
85 ```
86 (1b) If you plan on using `Intel` compilers (this point is expanded upon in step (5)):
87 ```
88 # Clone modified version of Spack to fit RRZE setup
89 git clone -b pkg/intel_mpi_fix https://github.com/davydden/spack.git .
90 export PATH=$WOODYHOME/spack/bin:$PATH
91 ```
92 (2) Load the `openmpi` module and let Spack find `GCC` compiler which is also loaded as a dependency. You might get a warning that spack has not detected any new compilers - this only means that the `compilers.yaml` file already has the correct version of `GCC` listed in it.
93 ```
94 module load openmpi/2.0.2-gcc
95 spack compiler find
96 ```
97 (3) Add `openmpi` as an external package, along with `python` and a few other self explanatory setting for `deal.ii`. That is done by adding the following to `~/.spack/linux/packages.yaml`:
98 ```
99 packages:
100   all:
101     compiler: [gcc]
102     providers:
103       mpi: [openmpi]
104       blas: [openblas]
105       lapack: [openblas]
106   openmpi:
107     version: [2.0.2]
108     paths:
109       openmpi@2.0.2%gcc@4.8.5: /apps/OpenMPI/2.0.2-gcc/
110     buildable: False
111   suite-sparse:
112     version: [5.1.0]
113   dealii:
114     variants: +optflags~python
115 ```
116 Those paths are the location where external packages can be found (i.e. `<prefix>` instead of `<prefix>/bin` or `<prefix>/lib`). `providers` section essentially tells Spack which packages to use to satisfy virtual dependencies such as `MPI`, `BLAS`, `LAPACK`, `ScaLAPACK`, etc. Here we also limit version of `suite-sparse` to `5.1.0` as we build with `gcc@4.8.5` whereas `5.2.0` requires at least `gcc@4.9`. 
117
118 (4) Now install deal.II:  `spack install dealii`.
119
120 (5) Here is an alternative setup with Intel compilers. Run `module load intel64/18.0up02` followed by `spack compiler find`. You should get the following new entry in `~/.spack/linux/compilers.yaml`:
121 ```
122 - compiler:
123     environment: {}
124     extra_rpaths: []
125     flags: {}
126     modules: []
127     operating_system: centos7
128     paths:
129       cc: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/icc
130       cxx: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/icpc
131       f77: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/ifort
132       fc: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/ifort
133     spec: intel@18.0.2
134     target: x86_64
135 ```
136 Edit it to set environment variable (with license) and extra rpaths:
137 ```
138     environment:
139       set:
140         INTEL_LICENSE_FILE: 1713@license4
141     extra_rpaths: # take from echo $LIBRARY_PATH
142      - /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/ipp/lib/intel64
143      - /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/compiler/lib/intel64_lin
144 ```
145 Then add to `~/.spack/linux/packages.yaml` paths to `intel-mpi`, `intel-mkl` as well as `cmake` which currently does not build with `Intel`:
146 ```
147 packages:
148   all:
149     compiler: [intel]
150     providers:
151       mpi: [intel-mpi]
152       blas: [intel-mkl]
153       lapack: [intel-mkl]
154       scalapack: [intel-mkl]
155   intel-mpi:
156     version: [2018.2.199]
157     paths:
158       intel-mpi@2018.2.199%intel@18.0.2: /apps/intel/ComposerXE2018/
159     buildable: False
160   intel-mkl:
161     version: [2018.2.199]
162     paths:
163       intel-mkl@2018.2.199%intel@18.0.2: /apps/intel/ComposerXE2018/
164     buildable: False
165   cmake:
166     version: [3.6.0]
167     paths:
168       cmake@3.6.0%intel@18.0.2: /apps/cmake/3.6.0/
169     buildable: False
170   suite-sparse:
171     version: [5.1.0]
172   dealii:
173     variants: +optflags~python
174 ```
175 Finally install `deal.II` 
176 ```
177 spack install -j 20 dealii%intel~assimp~petsc~slepc+mpi^intel-mpi^intel-mkl
178 ```
179 Note that `%intel` specified the compiler whereas `^intel-mpi` and `^intel-mkl` specified which implementation of MPI and BLAS/LAPACK we want to use. Here we also disabled few other packages that have issues building with `Intel` compilers.
180
181 See [this discussion](https://groups.google.com/d/msg/spack/NxyNTAZyMQg/Klu2CHR8GQAJ) on more info about using Intel compilers in Spack.
182
183
184 ## Enabling CUDA
185 You can build the current development version of `dealii` with CUDA. A possible configuration of `packages.yaml` is
186 ```
187 packages:
188  dealii:
189   version: ['develop']
190   variants: +cuda cuda_arch=52
191  cuda:
192   version: ['8.0.61']
193 ```
194 where we specified explicitly CUDA architecture as well as version of `cuda` to be used.
195
196 ## Environment Modules
197 Spack provides some integration with Environment Modules and Dotkit to make it easier to use the packages it installs. For a full description, read http://spack.readthedocs.io/en/latest/getting_started.html#environment-modules
198
199 To add the support for Environment Modules run
200 ```
201 spack install environment-modules
202 ```
203 Get the path to the prefix of `environment-modules` by:
204 ```
205 spack location --install-dir environment-modules
206 ```
207 and then add to `~/.bashrc` (or equivalent)
208 ```
209 MODULES_HOME=/path/to/environment-modules
210 source ${MODULES_HOME}/Modules/init/bash
211 . $SPACK_ROOT/share/spack/setup-env.sh
212 ```
213
214 If you install `deal.II` before setting up environment modules,
215 the module files have to be regenerated
216 ```
217 spack module refresh
218 ```
219
220 Then run
221 ```
222 spack load dealii
223 spack load cmake
224 ```
225 Now `DEAL_II_DIR` environment variable should be set appropriately and `cmake` executable will be available in path. Keep in mind that `spack load dealii` will also set `LD_LIBRARY_PATH` accordingly, this may or may not be what you need. An alternative is to use `export DEAL_II_DIR=$(spack location -i dealii)`.
226
227 ## System provided packages
228 Spack is flexible to use both self-compiled and system provided packages. 
229 In most cases this is desirable for `MPI`, which is already installed on computational clusters. To configure external packages you need to edit `~/.spack/linux/packages.yaml`. For `openmpi` this could be
230 ```
231 packages:
232   openmpi:
233     version: [1.8.8]
234     paths:
235       openmpi@1.8.8%gcc@6.2.0: /opt/openmpi-1.8.8
236     buildable: False
237 ```
238 In order to make sure that we use to build packages `1.8.8` version of `openmpi` and not the most recent one (i.e. `2.0.2`), we specified conretization preferences with `version: [1.8.8]`.
239
240 One can also specify which packages should be used to provide `mpi`, `blas/lapack` , preferred compilers and preferred variants:
241 ```
242 packages:
243   all:
244     compiler: [gcc,clang]
245     providers:
246       mpi: [openmpi]
247       blas: [openblas]
248       lapack: [openblas]
249     boost:
250       variants: +python
251 ```
252
253 For more elaborated discussion, see [Configuration Files in Spack](http://spack.readthedocs.io/en/latest/configuration.html).
254
255 ## Installing GCC
256 If your system does not provide any Fortran compiler or you want to have the most recent `gcc`,
257 you can install it by
258 ```
259 spack install gcc
260 ```
261
262 Assuming that you configured [Environment Modules](#environment-modules), load `gcc` and let Spack find the newly installed compilers:
263 ```
264 spack load gcc
265 spack compiler find
266 ```
267 Now you can install deal.II with `gcc`
268 ```
269 spack install dealii%gcc
270 ```
271
272 If you are on the mac, read the following instructions on [Mixed Toolchains](http://spack.readthedocs.io/en/latest/getting_started.html#mixed-toolchains).
273
274 On following these instructions, you will be able to install deal.II with clang+gfortran
275 ```
276 spack install dealii%clang
277 ```
278
279 ## Best practices using Spack:
280
281 Spack is complicated and flexible package manager primarily aimed at High-Performance-Computing.
282 Below are some examples of using Spack to build and develop deal.II:
283
284 ### Info:
285 If you are not sure which options a given package has, simply run
286 ```
287 spack info <package>
288 ```
289 The output will contain available versions, variants, dependencies and description:
290 ```
291 $ spack info dealii
292 CMakePackage:   dealii
293
294 Description:
295     C++ software library providing well-documented tools to build finite
296     element codes for a broad variety of PDEs.
297
298 Homepage: https://www.dealii.org
299
300 Preferred version:  
301     8.5.1      https://github.com/dealii/dealii/releases/download/v8.5.1/dealii-8.5.1.tar.gz
302
303 Safe versions:  
304     develop    [git] https://github.com/dealii/dealii.git
305     8.5.1      https://github.com/dealii/dealii/releases/download/v8.5.1/dealii-8.5.1.tar.gz
306     8.5.0      https://github.com/dealii/dealii/releases/download/v8.5.0/dealii-8.5.0.tar.gz
307     8.4.2      https://github.com/dealii/dealii/releases/download/v8.4.2/dealii-8.4.2.tar.gz
308     8.4.1      https://github.com/dealii/dealii/releases/download/v8.4.1/dealii-8.4.1.tar.gz
309     8.4.0      https://github.com/dealii/dealii/releases/download/v8.4.0/dealii-8.4.0.tar.gz
310     8.3.0      https://github.com/dealii/dealii/releases/download/v8.3.0/dealii-8.3.0.tar.gz
311     8.2.1      https://github.com/dealii/dealii/releases/download/v8.2.1/dealii-8.2.1.tar.gz
312     8.1.0      https://github.com/dealii/dealii/releases/download/v8.1.0/dealii-8.1.0.tar.gz
313
314 Variants:
315     Name [Default]               Allowed values          Description
316
317
318     adol-c [off]                 True, False             Compile with Adol-c
319     arpack [on]                  True, False             Compile with Arpack and
320                                                          PArpack (only with MPI)
321     build_type [DebugRelease]    Debug, Release,         The build type to build
322                                  DebugRelease            
323     doc [off]                    True, False             Compile with documentation
324     gsl [on]                     True, False             Compile with GSL
325     hdf5 [on]                    True, False             Compile with HDF5 (only with
326                                                          MPI)
327     int64 [off]                  True, False             Compile with 64 bit indices
328                                                          support
329     metis [on]                   True, False             Compile with Metis
330     mpi [on]                     True, False             Compile with MPI
331     nanoflann [off]              True, False             Compile with Nanoflann
332     netcdf [on]                  True, False             Compile with Netcdf (only with
333                                                          MPI)
334     oce [on]                     True, False             Compile with OCE
335     optflags [off]               True, False             Compile using additional
336                                                          optimization flags
337     p4est [on]                   True, False             Compile with P4est (only with
338                                                          MPI)
339     petsc [on]                   True, False             Compile with Petsc (only with
340                                                          MPI)
341     python [on]                  True, False             Compile with Python bindings
342     slepc [on]                   True, False             Compile with Slepc (only with
343                                                          Petsc and MPI)
344     sundials [off]               True, False             Compile with Sundials
345     trilinos [on]                True, False             Compile with Trilinos (only
346                                                          with MPI)
347
348 Installation Phases:
349     cmake    build    install
350
351 Build Dependencies:
352     adol-c     cmake     hdf5     muparser    oce     slepc         trilinos
353     arpack-ng  doxygen   lapack   nanoflann   p4set   suite-sparse  zlib
354     blas       graphivz  metis    netcdf      petsc   sundials      
355     boost      gsl       mpi      netcdf-cxx  python  tbb
356
357 Link Dependencies:
358     adol-c     doxygen   lapack   nanoflann   p4est   suite-sparse  zlib
359     arpack-ng  graphviz  metis    netcdf      petsc   sundials      
360     blas       graphviz  mpi      netcdf-cxx  python  tbb
361     boost      hdf5      muparser oce         slepc   trilinos
362
363 Run Dependencies:
364     None
365
366 Virtual Packages: 
367     None
368 ```
369
370 A lot of `spack` commands have help, for example
371 ```
372 $ spack install -h
373 usage: spack install [-h] [--only {package,dependencies}] [-j JOBS]
374                      [--keep-prefix] [--keep-stage] [--restage] [-n] [-v]
375                      [--fake] [-f] [--clean | --dirty] [--run-tests]
376                      [--log-format {junit}] [--log-file LOG_FILE]
377                      ...
378
379 build and install packages
380
381 positional arguments:
382   package               spec of the package to install
383
384 optional arguments:
385   -h, --help            show this help message and exit
386   --only {package,dependencies}
387                         select the mode of installation. the default is to
388                         install the package along with all its dependencies.
389                         alternatively one can decide to install only the
390                         package or only the dependencies
391   -j JOBS, --jobs JOBS  explicitly set number of make jobs. default is #cpus
392   --keep-prefix         don't remove the install prefix if installation fails
393   --keep-stage          don't remove the build stage if installation succeeds
394   --restage             if a partial install is detected, delete prior state
395   -n, --no-checksum     do not check packages against checksum
396   -v, --verbose         display verbose build output while installing
397   --fake                fake install. just remove prefix and create a fake
398                         file
399   -f, --file            install from file. Read specs to install from .yaml
400                         files
401   --clean               clean environment before installing package
402   --dirty               do NOT clean environment before installing
403   --run-tests           run package level tests during installation
404   --log-format {junit}  format to be used for log files
405   --log-file LOG_FILE   filename for the log file. if not passed a default
406                         will be used
407 ```
408
409 ### Extra options:
410 One can specify extra options for packages in the deal.II suite. For example if you want to have boost with `python` module, this can be done by
411 ```
412 spack install dealii@develop+mpi~python ^boost+python
413 ```
414
415 If you want to specify blas/lapack/mpi implementations, this can be done similarly
416 ```
417 spack install dealii@develop+mpi ^mpich
418 ```
419 To check which packages implement `mpi` run
420 ```
421 spack providers mpi
422 ```
423 One can also specify which Blas/Lapack implementation to use. For example to build deal.II suite with `atlas` run
424 ```
425 spack install dealii ^atlas
426 ```
427
428 ### Compiler flags
429 You can specify compiler flags on the command line as
430 ```
431 spack install dealii cppflags="-march=native -O3"
432 ```
433 Note that these flags will be inherited by dependencies such as `petsc`, `trilinos`, etc. Same can be done by declaring these flags in `~/.spack/compilers.yaml`:
434 ```
435 compilers:
436 - compiler:
437     modules: []
438     operating_system: centos6
439     paths:
440       cc: /usr/bin/gcc
441       cxx: /usr/bin/g++
442       f77: /usr/bin/gfortran
443       fc: /usr/bin/gfortran
444     flags:
445       cflags: -O3 -fPIC
446       cxxflags: -O3 -fPIC
447       cppflags: -O3 -fPIC
448     spec: gcc@4.7.2
449 ```
450
451 See this [google forum topic](https://groups.google.com/forum/?fromgroups#!topic/dealii/3Yjy8CBIrgU) for discussion on which flags to use. You can also use `spack install dealii+optflags` to enable extra optimization flags in release build.
452
453 ### Different versions coexisting:
454 One can easily have slightly different versions of deal.II side-by-side, e.g. to compile development version of deal.II with complex-valued PETSc and `gcc` compiler run
455 ```
456 spack install dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
457 ```
458 The good thing is that if you already have deal.ii built with real-valued petsc, then only `petsc`, `slepc` and `deal.ii` itself will be rebuild. Everything else (`trilinos`, `mumps`, `metis`, etc) will be reused.
459
460 One can use `environment-modules` (see above) to automatically set `DEAL_II_DIR` to the complex version: 
461 ```
462 spack load dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
463 ```
464
465 ### Filesystem Views:
466 If you prefer to have the whole dealii suite (and possible something else) symlinked into a single path (like `/usr/local`), one can use [Filesystem Views](http://spack.readthedocs.io/en/latest/workflows.html#filesystem-views):
467 ```
468 spack view -v symlink dealii_suite dealii@develop
469 ```
470 You can also add to this view other packages, i.e.
471 ```
472 spack view -v symlink dealii_suite the-silver-searcher
473 ```
474
475
476 ### Check before build:
477 It is often convenient to check which version of packages, compilers, variants etc will be used before actually starting installation. That can be done by examining the concretized spec via `spack spec` command, e.g. 
478 ```
479 spack spec dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
480 ```
481
482 The `spec` command has a useful flag `-I` which will show install status of dependencies in the graph.
483
484 ### Develop using Spack
485 Probably the easiest way to use Spack while contributing patches to the deal.II is the following. 
486 Install `deal.II` via Spack, go to its installation prefix and copy-paste the CMake command from `.spack/build.out`, which looks like
487 ```
488 'cmake' '/path/to/spack/var/spack/stage/dealii-develop-tkowxhk55kpi7facfh3ufipofyolt6h7/dealii' '-DCMAKE_INSTALL_PREFIX:PATH=path/to/spack/opt/spack/darwin-sierra-x86_64/clang-8.1.0-apple/dealii-develop-tkowxhk55kpi7facfh3ufipofyolt6h7' '-DCMAKE_BUILD_TYPE:STRING=DebugRelease' <more options>
489 ```
490 You would need to adjust the path to the `dea.II` source folder (first path) and should remove the `DCMAKE_INSTALL_PREFIX` as you probably don't want to accidentally override the version installed by Spack. 
491
492 Assuming that your build folder is within the `dealii` sources (tha'ts what `..\/` is for below), you can get this substitution done by
493 ```
494 $ cat $(spack location -i dealii)/.spack/build.out | grep "==> 'cmake'" | sed -e "s/[^ ]*[^ ]/'..\/'/3" | cut -d " " -f2-
495 ```
496
497 Before running `cmake` from the build folder, you may want to run 
498 ```
499 spack env dealii@develop+mpi^openmpi^openblas bash
500 ```
501 to make sure your environment (paths, variables, etc) is set exactly the same way as when compiling `deal.II` from Spack
502 (adjust the spec `dealii@develop+mpi^openmpi^openblas` to be what you use when you installed `deal.II`).
503
504 An alternative is to create a [Filesystem view](#filesystem-views) for an already installed library and then compile patched version of deal.II manually by providing path to the view for each dependency. 
505
506 ### Keep the stage to run unit tests
507 By default, the build folder (aka `stage`) for each package is created in a temporary system dependent location.
508 This gets purge by system on next restart.
509 If you want to keep the stage after the installation, you need to do two things:
510 First, make spack use a custom location for stage by adding the following to your `~/.spack/config.yaml`:
511 ```
512 config:
513   build_stage:
514     - $spack/var/spack/stage
515 ```
516 Second, prescribe an extra argument to `install` command to keep the stage after successful installation:
517 ```
518 spack install --keep-stage dealii@develop
519 ```
520
521 ### MKL and Licensed software
522 Spack supports installation of [licensed software](http://spack.readthedocs.io/en/latest/packaging_guide.html#license) as well as usage of [Licensed compilers](http://spack.readthedocs.io/en/latest/getting_started.html#licensed-compilers). For example in order to install MKL on Linux:
523
524 1. add `Intel` license file as `license.lic` file to `${SPACK_ROOT}/etc/spack/licenses/intel/`.
525 2. run `spack install dealii ^intel-mkl@11.3.2.210`
526
527 In order to configure Intel compilers see [this page](http://spack.readthedocs.io/en/latest/getting_started.html#vendor-specific-compiler-configuration).
528
529
530 ### Freeze package versions
531 Currently Spack does not try to re-use already installed packages. On another hand, by default
532 the most recent version of a package will be installed. When updating deal.II build (for example to use the new version of `trilinos`), the combination of the two factors may lead to recompilation of many other packages used in the deal.II suite when one of the main build dependency like `cmake` has a new version.
533
534 To circumvent the problem, the user can specify preferred versions of packages in `~/.spack/packages.yaml`:
535 ```
536 packages:
537   cmake:
538     version: [3.6.1]
539   curl:
540     version: [7.50.3]
541   openssl:
542     version: [1.0.2j]
543   python:
544     version: [2.7.12]
545 ```
546 This settings will be taken into account during conretization process and thus will help to avoid rebuilding most of the deal.II suite when, for example, `openssl` is updated to the new version.
547
548 ## Known issues using Spack:
549
550 ### Incompatible CMake versions
551
552 At the moment there is an incompatibility between deal.II and `cmake` with version 3.10 and greater.
553 To install deal.II using an earlier version of `cmake`, either use the `packages.yaml` file to freeze `cmake` to an earlier version, or specify the version at install time, e.g.
554 ```
555 spack install dealii^cmake@3.9.4
556 ```

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.