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

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.