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

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.