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

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.