Remove redundant command
[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 99f678035a279cf85a32a4fdbd98a117b9c1832f
52 ```
53
54 **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
55 ```
56 spack install --test=root dealii
57 ```
58 **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.
59 Additional option `--test=root` instructs Spack to run quick tests for `dealii`.
60
61 Before configuring your project you need to set `DEAL_II_DIR` by 
62 ```
63 export DEAL_II_DIR=$(spack location -i dealii)
64 ```
65 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).
66
67
68 ## Installation example on a Centos7 cluster (Emmy cluster of RRZE, Erlangen, Germany)
69 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.
70
71 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:
72
73 (1) Download spack
74 ```
75 mkdir $WOODYHOME/spack
76 cd $WOODYHOME/spack
77 module load git
78 # clone modified version of Spack to fit RRZE setup
79 git clone -b pkg/intel_mpi_fix https://github.com/davydden/spack.git .
80 export PATH=$WOODYHOME/spack/bin:$PATH
81 ```
82 (2) Load `openmpi` and let Spack find GCC compiler which is also loaded as a dependency:
83 ```
84 module load openmpi/2.0.2-gcc
85 spack compiler find
86 ```
87 (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`
88 ```
89 packages:
90   all:
91     compiler: [gcc]
92     providers:
93       mpi: [openmpi]
94       blas: [openblas]
95       lapack: [openblas]
96   openmpi:
97     version: [2.0.2]
98     paths:
99       openmpi@2.0.2%gcc@4.8.5: /apps/OpenMPI/2.0.2-gcc/
100     buildable: False
101   suite-sparse:
102     version: [5.1.0]
103   dealii:
104     variants: +optflags~python
105 ```
106 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`. 
107
108 (4) Now install deal.II:  `spack install dealii`.
109
110 (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`:
111 ```
112 - compiler:
113     environment: {}
114     extra_rpaths: []
115     flags: {}
116     modules: []
117     operating_system: centos7
118     paths:
119       cc: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/icc
120       cxx: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/icpc
121       f77: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/ifort
122       fc: /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/bin/intel64/ifort
123     spec: intel@18.0.2
124     target: x86_64
125 ```
126 Edit it to set environment variable (with license) and extra rpaths:
127 ```
128     environment:
129       set:
130         INTEL_LICENSE_FILE: 1713@license4
131     extra_rpaths: # take from echo $LIBRARY_PATH
132      - /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/ipp/lib/intel64
133      - /apps/intel/ComposerXE2018/compilers_and_libraries_2018.2.199/linux/compiler/lib/intel64_lin
134 ```
135 Then add to `~/.spack/linux/packages.yaml` paths to `intel-mpi`, `intel-mkl` as well as `cmake` which currently does not build with `Intel`:
136 ```
137 packages:
138   all:
139     compiler: [intel]
140     providers:
141       mpi: [intel-mpi]
142       blas: [intel-mkl]
143       lapack: [intel-mkl]
144       scalapack: [intel-mkl]
145   intel-mpi:
146     version: [2018.2.199]
147     paths:
148       intel-mpi@2018.2.199%intel@18.0.2: /apps/intel/ComposerXE2018/
149     buildable: False
150   intel-mkl:
151     version: [2018.2.199]
152     paths:
153       intel-mkl@2018.2.199%intel@18.0.2: /apps/intel/ComposerXE2018/
154     buildable: False
155   cmake:
156     version: [3.6.0]
157     paths:
158       cmake@3.6.0%intel@18.0.2: /apps/cmake/3.6.0/
159     buildable: False
160   suite-sparse:
161     version: [5.1.0]
162   dealii:
163     variants: +optflags~python
164 ```
165 Finally install `deal.II` 
166 ```
167 spack install -j 20 dealii%intel~assimp~petsc~slepc+mpi^intel-mpi^intel-mkl
168 ```
169 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.
170
171 See [this discussion](https://groups.google.com/d/msg/spack/NxyNTAZyMQg/Klu2CHR8GQAJ) on more info about using Intel compilers in Spack.
172
173
174 ## Enabling CUDA
175 You can build the current development version of `dealii` with CUDA. A possible configuration of `packages.yaml` is
176 ```
177 packages:
178  dealii:
179   version: ['develop']
180   variants: +cuda cuda_arch=52
181  cuda:
182   version: ['8.0.61']
183 ```
184 where we specified explicitly CUDA architecture as well as version of `cuda` to be used.
185
186 ## Environment Modules
187 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
188
189 To add the support for Environment Modules run
190 ```
191 spack install environment-modules
192 ```
193 Get the path to the prefix of `environment-modules` by:
194 ```
195 spack location --install-dir environment-modules
196 ```
197 and then add to `~/.bashrc` (or equivalent)
198 ```
199 MODULES_HOME=/path/to/environment-modules
200 source ${MODULES_HOME}/Modules/init/bash
201 . $SPACK_ROOT/share/spack/setup-env.sh
202 ```
203
204 If you install `deal.II` before setting up environment modules,
205 the module files have to be regenerated
206 ```
207 spack module refresh
208 ```
209
210 Then run
211 ```
212 spack load dealii
213 spack load cmake
214 ```
215 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)`.
216
217 ## System provided packages
218 Spack is flexible to use both self-compiled and system provided packages. 
219 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
220 ```
221 packages:
222   openmpi:
223     version: [1.8.8]
224     paths:
225       openmpi@1.8.8%gcc@6.2.0: /opt/openmpi-1.8.8
226     buildable: False
227 ```
228 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]`.
229
230 One can also specify which packages should be used to provide `mpi`, `blas/lapack` , preferred compilers and preferred variants:
231 ```
232 packages:
233   all:
234     compiler: [gcc,clang]
235     providers:
236       mpi: [openmpi]
237       blas: [openblas]
238       lapack: [openblas]
239     boost:
240       variants: +python
241 ```
242
243 For more elaborated discussion, see [Configuration Files in Spack](http://spack.readthedocs.io/en/latest/configuration.html).
244
245 ## Installing GCC
246 If your system does not provide any Fortran compiler or you want to have the most recent `gcc`,
247 you can install it by
248 ```
249 spack install gcc
250 ```
251
252 Assuming that you configured [Environment Modules](#environment-modules), load `gcc` and let Spack find the newly installed compilers:
253 ```
254 spack load gcc
255 spack compiler find
256 ```
257 Now you can install deal.II with `gcc`
258 ```
259 spack install dealii%gcc
260 ```
261
262 If you are on the mac, read the following instructions on [Mixed Toolchains](http://spack.readthedocs.io/en/latest/getting_started.html#mixed-toolchains).
263
264 On following these instructions, you will be able to install deal.II with clang+gfortran
265 ```
266 spack install dealii%clang
267 ```
268
269 ## Best practices using Spack:
270
271 Spack is complicated and flexible package manager primarily aimed at High-Performance-Computing.
272 Below are some examples of using Spack to build and develop deal.II:
273
274 ### Info:
275 If you are not sure which options a given package has, simply run
276 ```
277 spack info <package>
278 ```
279 The output will contain available versions, variants, dependencies and description:
280 ```
281 $ spack info dealii
282 CMakePackage:   dealii
283
284 Description:
285     C++ software library providing well-documented tools to build finite
286     element codes for a broad variety of PDEs.
287
288 Homepage: https://www.dealii.org
289
290 Preferred version:  
291     8.5.1      https://github.com/dealii/dealii/releases/download/v8.5.1/dealii-8.5.1.tar.gz
292
293 Safe versions:  
294     develop    [git] https://github.com/dealii/dealii.git
295     8.5.1      https://github.com/dealii/dealii/releases/download/v8.5.1/dealii-8.5.1.tar.gz
296     8.5.0      https://github.com/dealii/dealii/releases/download/v8.5.0/dealii-8.5.0.tar.gz
297     8.4.2      https://github.com/dealii/dealii/releases/download/v8.4.2/dealii-8.4.2.tar.gz
298     8.4.1      https://github.com/dealii/dealii/releases/download/v8.4.1/dealii-8.4.1.tar.gz
299     8.4.0      https://github.com/dealii/dealii/releases/download/v8.4.0/dealii-8.4.0.tar.gz
300     8.3.0      https://github.com/dealii/dealii/releases/download/v8.3.0/dealii-8.3.0.tar.gz
301     8.2.1      https://github.com/dealii/dealii/releases/download/v8.2.1/dealii-8.2.1.tar.gz
302     8.1.0      https://github.com/dealii/dealii/releases/download/v8.1.0/dealii-8.1.0.tar.gz
303
304 Variants:
305     Name [Default]               Allowed values          Description
306
307
308     adol-c [off]                 True, False             Compile with Adol-c
309     arpack [on]                  True, False             Compile with Arpack and
310                                                          PArpack (only with MPI)
311     build_type [DebugRelease]    Debug, Release,         The build type to build
312                                  DebugRelease            
313     doc [off]                    True, False             Compile with documentation
314     gsl [on]                     True, False             Compile with GSL
315     hdf5 [on]                    True, False             Compile with HDF5 (only with
316                                                          MPI)
317     int64 [off]                  True, False             Compile with 64 bit indices
318                                                          support
319     metis [on]                   True, False             Compile with Metis
320     mpi [on]                     True, False             Compile with MPI
321     nanoflann [off]              True, False             Compile with Nanoflann
322     netcdf [on]                  True, False             Compile with Netcdf (only with
323                                                          MPI)
324     oce [on]                     True, False             Compile with OCE
325     optflags [off]               True, False             Compile using additional
326                                                          optimization flags
327     p4est [on]                   True, False             Compile with P4est (only with
328                                                          MPI)
329     petsc [on]                   True, False             Compile with Petsc (only with
330                                                          MPI)
331     python [on]                  True, False             Compile with Python bindings
332     slepc [on]                   True, False             Compile with Slepc (only with
333                                                          Petsc and MPI)
334     sundials [off]               True, False             Compile with Sundials
335     trilinos [on]                True, False             Compile with Trilinos (only
336                                                          with MPI)
337
338 Installation Phases:
339     cmake    build    install
340
341 Build Dependencies:
342     adol-c     cmake     hdf5     muparser    oce     slepc         trilinos
343     arpack-ng  doxygen   lapack   nanoflann   p4set   suite-sparse  zlib
344     blas       graphivz  metis    netcdf      petsc   sundials      
345     boost      gsl       mpi      netcdf-cxx  python  tbb
346
347 Link Dependencies:
348     adol-c     doxygen   lapack   nanoflann   p4est   suite-sparse  zlib
349     arpack-ng  graphviz  metis    netcdf      petsc   sundials      
350     blas       graphviz  mpi      netcdf-cxx  python  tbb
351     boost      hdf5      muparser oce         slepc   trilinos
352
353 Run Dependencies:
354     None
355
356 Virtual Packages: 
357     None
358 ```
359
360 A lot of `spack` commands have help, for example
361 ```
362 $ spack install -h
363 usage: spack install [-h] [--only {package,dependencies}] [-j JOBS]
364                      [--keep-prefix] [--keep-stage] [--restage] [-n] [-v]
365                      [--fake] [-f] [--clean | --dirty] [--run-tests]
366                      [--log-format {junit}] [--log-file LOG_FILE]
367                      ...
368
369 build and install packages
370
371 positional arguments:
372   package               spec of the package to install
373
374 optional arguments:
375   -h, --help            show this help message and exit
376   --only {package,dependencies}
377                         select the mode of installation. the default is to
378                         install the package along with all its dependencies.
379                         alternatively one can decide to install only the
380                         package or only the dependencies
381   -j JOBS, --jobs JOBS  explicitly set number of make jobs. default is #cpus
382   --keep-prefix         don't remove the install prefix if installation fails
383   --keep-stage          don't remove the build stage if installation succeeds
384   --restage             if a partial install is detected, delete prior state
385   -n, --no-checksum     do not check packages against checksum
386   -v, --verbose         display verbose build output while installing
387   --fake                fake install. just remove prefix and create a fake
388                         file
389   -f, --file            install from file. Read specs to install from .yaml
390                         files
391   --clean               clean environment before installing package
392   --dirty               do NOT clean environment before installing
393   --run-tests           run package level tests during installation
394   --log-format {junit}  format to be used for log files
395   --log-file LOG_FILE   filename for the log file. if not passed a default
396                         will be used
397 ```
398
399 ### Extra options:
400 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
401 ```
402 spack install dealii@develop+mpi~python ^boost+python
403 ```
404
405 If you want to specify blas/lapack/mpi implementations, this can be done similarly
406 ```
407 spack install dealii@develop+mpi ^mpich
408 ```
409 To check which packages implement `mpi` run
410 ```
411 spack providers mpi
412 ```
413 One can also specify which Blas/Lapack implementation to use. For example to build deal.II suite with `atlas` run
414 ```
415 spack install dealii ^atlas
416 ```
417
418 ### Compiler flags
419 You can specify compiler flags on the command line as
420 ```
421 spack install dealii cppflags="-march=native -O3"
422 ```
423 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`:
424 ```
425 compilers:
426 - compiler:
427     modules: []
428     operating_system: centos6
429     paths:
430       cc: /usr/bin/gcc
431       cxx: /usr/bin/g++
432       f77: /usr/bin/gfortran
433       fc: /usr/bin/gfortran
434     flags:
435       cflags: -O3 -fPIC
436       cxxflags: -O3 -fPIC
437       cppflags: -O3 -fPIC
438     spec: gcc@4.7.2
439 ```
440
441 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.
442
443 ### Different versions coexisting:
444 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
445 ```
446 spack install dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
447 ```
448 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.
449
450 One can use `environment-modules` (see above) to automatically set `DEAL_II_DIR` to the complex version: 
451 ```
452 spack load dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
453 ```
454
455 ### Filesystem Views:
456 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):
457 ```
458 spack view -v symlink dealii_suite dealii@develop
459 ```
460 You can also add to this view other packages, i.e.
461 ```
462 spack view -v symlink dealii_suite the-silver-searcher
463 ```
464
465
466 ### Check before build:
467 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. 
468 ```
469 spack spec dealii@develop+mpi+petsc~int64%gcc ^petsc+complex~hypre
470 ```
471
472 The `spec` command has a useful flag `-I` which will show install status of dependencies in the graph.
473
474 ### Develop using Spack
475 Probably the easiest way to use Spack while contributing patches to the deal.II is the following. 
476 Install `deal.II` via Spack, go to its installation prefix and copy-paste the CMake command from `.spack/build.out`, which looks like
477 ```
478 '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>
479 ```
480 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. 
481
482 Assuming that your build folder is within the `dealii` sources (tha'ts what `..\/` is for below), you can get this substitution done by
483 ```
484 $ cat $(spack location -i dealii)/.spack/build.out | grep "==> 'cmake'" | sed -e "s/[^ ]*[^ ]/'..\/'/3" | cut -d " " -f2-
485 ```
486
487 Before running `cmake` from the build folder, you may want to run 
488 ```
489 spack env dealii@develop+mpi^openmpi^openblas bash
490 ```
491 to make sure your environment (paths, variables, etc) is set exactly the same way as when compiling `deal.II` from Spack
492 (adjust the spec `dealii@develop+mpi^openmpi^openblas` to be what you use when you installed `deal.II`).
493
494 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. 
495
496 ### Keep the stage to run unit tests
497 By default, the build folder (aka `stage`) for each package is created in a temporary system dependent location.
498 This gets purge by system on next restart.
499 If you want to keep the stage after the installation, you need to do two things:
500 First, make spack use a custom location for stage by adding the following to your `~/.spack/config.yaml`:
501 ```
502 config:
503   build_stage:
504     - $spack/var/spack/stage
505 ```
506 Second, prescribe an extra argument to `install` command to keep the stage after successful installation:
507 ```
508 spack install --keep-stage dealii@develop
509 ```
510
511 ### MKL and Licensed software
512 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:
513
514 1. add `Intel` license file as `license.lic` file to `${SPACK_ROOT}/etc/spack/licenses/intel/`.
515 2. run `spack install dealii ^intel-mkl@11.3.2.210`
516
517 In order to configure Intel compilers see [this page](http://spack.readthedocs.io/en/latest/getting_started.html#vendor-specific-compiler-configuration).
518
519
520 ### Freeze package versions
521 Currently Spack does not try to re-use already installed packages. On another hand, by default
522 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.
523
524 To circumvent the problem, the user can specify preferred versions of packages in `~/.spack/packages.yaml`:
525 ```
526 packages:
527   cmake:
528     version: [3.6.1]
529   curl:
530     version: [7.50.3]
531   openssl:
532     version: [1.0.2j]
533   python:
534     version: [2.7.12]
535 ```
536 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.
537
538 ## Known issues using Spack:
539
540 ### Incompatible CMake versions
541
542 At the moment there is an incompatibility between deal.II and `cmake` with version 3.10 and greater.
543 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.
544 ```
545 spack install dealii^cmake@3.9.4
546 ```

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.