admin/containers/scripted_gmx_docker_builds.py

   1 #!/usr/bin/env python
   2 #
   3 # This file is part of the GROMACS molecular simulation package.
   4 #
   5 # Copyright (c) 2020,2021, by the GROMACS development team, led by
   6 # Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   7 # and including many others, as listed in the AUTHORS file in the
   8 # top-level source directory and at http://www.gromacs.org.
   9 #
  10 # GROMACS is free software; you can redistribute it and/or
  11 # modify it under the terms of the GNU Lesser General Public License
  12 # as published by the Free Software Foundation; either version 2.1
  13 # of the License, or (at your option) any later version.
  14 #
  15 # GROMACS is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 # Lesser General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU Lesser General Public
  21 # License along with GROMACS; if not, see
  22 # http://www.gnu.org/licenses, or write to the Free Software Foundation,
  23 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  24 #
  25 # If you want to redistribute modifications to GROMACS, please
  26 # consider that scientific software is very special. Version
  27 # control is crucial - bugs must be traceable. We will be happy to
  28 # consider code for inclusion in the official distribution, but
  29 # derived work must not be called official GROMACS. Details are found
  30 # in the README & COPYING files - if they are missing, get the
  31 # official version at http://www.gromacs.org.
  32 #
  33 # To help us fund GROMACS development, we humbly ask that you cite
  34 # the research papers on the package. Check out http://www.gromacs.org.
  35
  36 """Building block based Dockerfile generation for CI testing images.
  37
  38 Generates a set of docker images used for running GROMACS CI on Gitlab.
  39 The images are prepared according to a selection of build configuration targets
  40 that hope to cover a broad enough scope of different possible systems,
  41 allowing us to check compiler types and versions, as well as libraries used
  42 for accelerators and parallel communication systems. Each combinations is
  43 described as an entry in the build_configs dictionary, with the script
  44 analysing the logic and adding build stages as needed.
  45
  46 Based on the example script provided by the NVidia HPCCM repository.
  47
  48 Reference:
  49     `NVidia HPC Container Maker <https://github.com/NVIDIA/hpc-container-maker>`__
  50
  51 Authors:
  52     * Paul Bauer <paul.bauer.q@gmail.com>
  53     * Eric Irrgang <ericirrgang@gmail.com>
  54     * Joe Jordan <e.jjordan12@gmail.com>
  55     * Mark Abraham <mark.j.abraham@gmail.com>
  56
  57 Usage::
  58
  59     $ python3 scripted_gmx_docker_builds.py --help
  60     $ python3 scripted_gmx_docker_builds.py --format docker > Dockerfile && docker build .
  61     $ python3 scripted_gmx_docker_builds.py | docker build -
  62
  63 See Also:
  64     :file:`buildall.sh`
  65
  66 """
  67
  68 import argparse
  69 import collections
  70 import typing
  71 from distutils.version import StrictVersion
  72
  73 import hpccm
  74 import hpccm.config
  75 from hpccm.building_blocks.base import bb_base
  76
  77 try:
  78     import utility
  79 except ImportError:
  80     raise RuntimeError(
  81         'This module assumes availability of supporting modules in the same directory. Add the directory to '
  82         'PYTHONPATH or invoke Python from within the module directory so module location can be resolved.')
  83
  84 # Basic packages for all final images.
  85 _common_packages = ['build-essential',
  86                     'ca-certificates',
  87                     'ccache',
  88                     'git',
  89                     'gnupg',
  90                     'gpg-agent',
  91                     'libfftw3-dev',
  92                     'libhwloc-dev',
  93                     'liblapack-dev',
  94                     'libx11-dev',
  95                     'moreutils',
  96                     'ninja-build',
  97                     'rsync',
  98                     'valgrind',
  99                     'vim',
 100                     'wget',
 101                     'xsltproc']
 102
 103 _opencl_extra_packages = [
 104     'nvidia-opencl-dev',
 105     # The following require apt_ppas=['ppa:intel-opencl/intel-opencl']
 106     'intel-opencl-icd',
 107     'ocl-icd-libopencl1',
 108     'ocl-icd-opencl-dev',
 109     'opencl-headers',
 110     # The following require
 111     #             apt_keys=['http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key'],
 112     #             apt_repositories=['deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main']
 113     'libelf1',
 114     'rocm-opencl',
 115     'rocm-dev',
 116     'clinfo'
 117 ]
 118
 119 # Extra packages needed to build Python installations from source.
 120 _python_extra_packages = ['build-essential',
 121                           'ca-certificates',
 122                           'ccache',
 123                           'curl',
 124                           'git',
 125                           'libbz2-dev',
 126                           'libffi-dev',
 127                           'liblzma-dev',
 128                           'libncurses5-dev',
 129                           'libncursesw5-dev',
 130                           'libreadline-dev',
 131                           'libsqlite3-dev',
 132                           'libssl-dev',
 133                           'llvm',
 134                           'python-openssl',
 135                           'vim',
 136                           'wget',
 137                           'zlib1g-dev']
 138
 139 # Extra packages needed for images for building documentation.
 140 _docs_extra_packages = ['autoconf',
 141                         'automake',
 142                         'autopoint',
 143                         'autotools-dev',
 144                         'bison',
 145                         'flex',
 146                         'ghostscript',
 147                         'graphviz',
 148                         'help2man',
 149                         'imagemagick',
 150                         'libtool',
 151                         'linkchecker',
 152                         'mscgen',
 153                         'm4',
 154                         'openssh-client',
 155                         'texinfo',
 156                         'texlive-latex-base',
 157                         'texlive-latex-extra',
 158                         'texlive-fonts-recommended',
 159                         'texlive-fonts-extra']
 160
 161 # Parse command line arguments
 162 parser = argparse.ArgumentParser(description='GROMACS CI image creation script',
 163                                  parents=[utility.parser])
 164
 165 parser.add_argument('--format', type=str, default='docker',
 166                     choices=['docker', 'singularity'],
 167                     help='Container specification format (default: docker)')
 168
 169
 170 def base_image_tag(args) -> str:
 171     # Check if we use CUDA images or plain linux images
 172     if args.cuda is not None:
 173         cuda_version_tag = 'nvidia/cuda:' + args.cuda + '-devel'
 174         if args.centos is not None:
 175             cuda_version_tag += '-centos' + args.centos
 176         elif args.ubuntu is not None:
 177             cuda_version_tag += '-ubuntu' + args.ubuntu
 178         else:
 179             raise RuntimeError('Logic error: no Linux distribution selected.')
 180
 181         base_image_tag = cuda_version_tag
 182     else:
 183         if args.centos is not None:
 184             base_image_tag = 'centos:centos' + args.centos
 185         elif args.ubuntu is not None:
 186             base_image_tag = 'ubuntu:' + args.ubuntu
 187         else:
 188             raise RuntimeError('Logic error: no Linux distribution selected.')
 189     return base_image_tag
 190
 191
 192 def get_llvm_packages(args) -> typing.Iterable[str]:
 193     # If we use the package version of LLVM, we need to install extra packages for it.
 194     if (args.llvm is not None) and (args.tsan is None):
 195         return ['libomp-dev',
 196                 'libomp5',
 197                 'clang-format-' + str(args.llvm),
 198                 'clang-tidy-' + str(args.llvm)]
 199     else:
 200         return []
 201
 202 def get_opencl_packages(args) -> typing.Iterable[str]:
 203     if (args.doxygen is None) and (args.oneapi is None):
 204         return _opencl_extra_packages
 205     else:
 206         return []
 207
 208 def get_compiler(args, compiler_build_stage: hpccm.Stage = None) -> bb_base:
 209     # Compiler
 210     if args.llvm is not None:
 211         # Build our own version instead to get TSAN + OMP
 212         if args.tsan is not None:
 213             if compiler_build_stage is not None:
 214                 compiler = compiler_build_stage.runtime(_from='tsan')
 215             else:
 216                 raise RuntimeError('No TSAN compiler build stage!')
 217         # Build the default compiler if we don't need special support
 218         else:
 219             compiler = hpccm.building_blocks.llvm(extra_repository=True, version=args.llvm)
 220
 221     elif args.oneapi is not None:
 222         if compiler_build_stage is not None:
 223             compiler = compiler_build_stage.runtime(_from='oneapi')
 224             # Prepare the toolchain (needed only for builds done within the Dockerfile, e.g.
 225             # OpenMPI builds, which don't currently work for other reasons)
 226             oneapi_toolchain = hpccm.toolchain(CC=f'/opt/intel/oneapi/compiler/{args.oneapi}/linux/bin/intel64/icx',
 227                                                CXX=f'/opt/intel/oneapi/compiler/{args.oneapi}/linux/bin/intel64/icpx')
 228             setattr(compiler, 'toolchain', oneapi_toolchain)
 229
 230         else:
 231             raise RuntimeError('No oneAPI compiler build stage!')
 232
 233     elif args.gcc is not None:
 234         compiler = hpccm.building_blocks.gnu(extra_repository=True,
 235                                              version=args.gcc,
 236                                              fortran=False)
 237     else:
 238         raise RuntimeError('Logic error: no compiler toolchain selected.')
 239     return compiler
 240
 241
 242 def get_mpi(args, compiler):
 243     # If needed, add MPI to the image
 244     if args.mpi is not None:
 245         if args.mpi == 'openmpi':
 246             use_cuda = False
 247             if args.cuda is not None:
 248                 use_cuda = True
 249
 250             if hasattr(compiler, 'toolchain'):
 251                 if args.oneapi is not None:
 252                     raise RuntimeError('oneAPI building OpenMPI is not supported')
 253                 return hpccm.building_blocks.openmpi(toolchain=compiler.toolchain, cuda=use_cuda, infiniband=False)
 254             else:
 255                 raise RuntimeError('compiler is not an HPCCM compiler building block!')
 256
 257         elif args.mpi == 'impi':
 258             # TODO Intel MPI from the oneAPI repo is not working reliably,
 259             # reasons are unclear. When solved, add packagages called:
 260             # 'intel-oneapi-mpi', 'intel-oneapi-mpi-devel'
 261             # during the compiler stage.
 262             # TODO also consider hpccm's intel_mpi package if that doesn't need
 263             # a license to run.
 264             raise RuntimeError('Intel MPI recipe not implemented yet.')
 265         else:
 266             raise RuntimeError('Requested unknown MPI implementation.')
 267     else:
 268         return None
 269
 270
 271 def get_clfft(args):
 272     if (args.clfft is not None):
 273         return hpccm.building_blocks.generic_cmake(
 274             repository='https://github.com/clMathLibraries/clFFT.git',
 275             prefix='/usr/local', recursive=True, branch=args.clfft, directory='clFFT/src')
 276     else:
 277         return None
 278
 279
 280 def add_tsan_compiler_build_stage(input_args, output_stages: typing.Mapping[str, hpccm.Stage]):
 281     """Isolate the expensive TSAN preparation stage.
 282
 283     This is a very expensive stage, but has few and disjoint dependencies, and
 284     its output is easily compartmentalized (/usr/local) so we can isolate this
 285     build stage to maximize build cache hits and reduce rebuild time, bookkeeping,
 286     and final image size.
 287     """
 288     if not isinstance(output_stages, collections.abc.MutableMapping):
 289         raise RuntimeError('Need output_stages container.')
 290     tsan_stage = hpccm.Stage()
 291     tsan_stage += hpccm.primitives.baseimage(image=base_image_tag(input_args), _as='tsan')
 292
 293     tsan_stage += hpccm.building_blocks.packages(ospackages=['git', 'ca-certificates', 'build-essential', 'cmake'])
 294     # CMake will get duplicated later, but this is an expensive image, and it isn't worth optimizing
 295     # out that duplication...
 296     tsan_stage += hpccm.building_blocks.python(python3=True, python2=False, devel=False)
 297
 298     compiler_branch = 'release/' + str(input_args.llvm) + '.x'
 299     tsan_stage += hpccm.building_blocks.generic_cmake(
 300         repository='https://github.com/llvm/llvm-project.git',
 301         directory='/var/tmp/llvm-project/llvm/',
 302         prefix='/usr/local', recursive=True, branch=compiler_branch,
 303         cmake_opts=['-D CMAKE_BUILD_TYPE=Release', '-D LLVM_ENABLE_PROJECTS="clang;openmp;clang-tools-extra;compiler-rt;lld"',
 304                     '-D LIBOMP_TSAN_SUPPORT=on'],
 305         postinstall=['ln -s /usr/local/bin/clang++ /usr/local/bin/clang++-' + str(input_args.llvm),
 306                      'ln -s /usr/local/bin/clang-format /usr/local/bin/clang-format-' + str(input_args.llvm),
 307                      'ln -s /usr/local/bin/clang-tidy /usr/local/bin/clang-tidy-' + str(input_args.llvm),
 308                      'ln -s /usr/local/share/clang/run-clang-tidy.py /usr/local/bin/run-clang-tidy-' + str(input_args.llvm) + '.py',
 309                      'ln -s /usr/local/bin/run-clang-tidy-' + str(input_args.llvm) + '.py /usr/local/bin/run-clang-tidy-' + str(input_args.llvm),
 310                      'ln -s /usr/local/libexec/c++-analyzer /usr/local/bin/c++-analyzer-' + str(input_args.llvm)])
 311     output_stages['compiler_build'] = tsan_stage
 312
 313 def oneapi_runtime(_from='0'):
 314     oneapi_runtime_stage = hpccm.Stage()
 315     oneapi_runtime_stage += hpccm.primitives.copy(_from='oneapi-build',
 316                                                   files={"/opt/intel": "/opt/intel",
 317                                                          "/etc/bash.bashrc": "/etc/bash.bashrc"})
 318     return oneapi_runtime_stage
 319
 320 def add_oneapi_compiler_build_stage(input_args, output_stages: typing.Mapping[str, hpccm.Stage]):
 321     """Isolate the oneAPI preparation stage.
 322
 323     This stage is isolated so that its installed components are minimized in the
 324     final image (chiefly /opt/intel) and its environment setup script can be
 325     sourced. This also helps with rebuild time and final image size.
 326     """
 327     if not isinstance(output_stages, collections.abc.MutableMapping):
 328         raise RuntimeError('Need output_stages container.')
 329     oneapi_stage = hpccm.Stage()
 330     oneapi_stage += hpccm.primitives.baseimage(image=base_image_tag(input_args), _as='oneapi-build')
 331
 332     version = str(input_args.oneapi)
 333
 334     # Add required components for the next stage (both for hpccm and Intel's setvars.sh script)
 335     oneapi_stage += hpccm.building_blocks.packages(ospackages=['wget', 'gnupg2', 'ca-certificates', 'lsb-release'])
 336     oneapi_stage += hpccm.building_blocks.packages(
 337         apt_keys=['https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB'],
 338         apt_repositories=['deb https://apt.repos.intel.com/oneapi all main'],
 339         # Add minimal packages (not the whole HPC toolkit!)
 340         ospackages=[f'intel-oneapi-dpcpp-cpp-{version}',
 341             f'intel-oneapi-openmp-{version}',
 342             f'intel-oneapi-mkl-{version}',
 343             f'intel-oneapi-mkl-devel-{version}']
 344     )
 345     # Ensure that all bash shells on the final container will have access to oneAPI
 346     oneapi_stage += hpccm.primitives.shell(
 347             commands=['echo "source /opt/intel/oneapi/setvars.sh" >> /etc/bash.bashrc',
 348                       'unlink /opt/intel/oneapi/compiler/latest',
 349                      f'ln -sf /opt/intel/oneapi/compiler/{version} /opt/intel/oneapi/compiler/latest']
 350             )
 351     setattr(oneapi_stage, 'runtime', oneapi_runtime)
 352
 353     output_stages['compiler_build'] = oneapi_stage
 354
 355 def prepare_venv(version: StrictVersion) -> typing.Sequence[str]:
 356     """Get shell commands to set up the venv for the requested Python version."""
 357     major = version.version[0]
 358     minor = version.version[1]  # type: int
 359
 360     pyenv = '$HOME/.pyenv/bin/pyenv'
 361
 362     py_ver = f'{major}.{minor}'
 363     venv_path = f'$HOME/venv/py{py_ver}'
 364     commands = [f'$({pyenv} prefix `{pyenv} whence python{py_ver}`)/bin/python -m venv {venv_path}']
 365
 366     commands.append(f'{venv_path}/bin/python -m pip install --upgrade pip setuptools')
 367     # Install dependencies for building and testing gmxapi Python package.
 368     # WARNING: Please keep this list synchronized with python_packaging/requirements-test.txt
 369     # TODO: Get requirements.txt from an input argument.
 370     commands.append(f"""{venv_path}/bin/python -m pip install --upgrade \
 371             'cmake>=3.13' \
 372             'flake8>=3.7.7' \
 373             'gcovr>=4.2' \
 374             'mpi4py>=3.0.3' \
 375             'networkx>=2.0' \
 376             'numpy>=1' \
 377             'pip>=10.1' \
 378             'Pygments>=2.2.0' \
 379             'pytest>=3.9' \
 380             'setuptools>=42' \
 381             'scikit-build>=0.10' \
 382             'Sphinx>=1.6.3' \
 383             'sphinxcontrib-plantuml>=0.14'""")
 384
 385     # TODO: Remove 'importlib_resources' dependency when Python >=3.7 is required.
 386     if minor == 6:
 387         commands.append(f"""{venv_path}/bin/python -m pip install --upgrade \
 388                 'importlib_resources'""")
 389
 390     return commands
 391
 392
 393 def add_python_stages(building_blocks: typing.Mapping[str, bb_base],
 394                       input_args,
 395                       output_stages: typing.MutableMapping[str, hpccm.Stage]):
 396     """Add the stage(s) necessary for the requested venvs.
 397
 398     One intermediate build stage is created for each venv (see --venv option).
 399
 400     Each stage partially populates Python installations and venvs in the home
 401     directory. The home directory is collected by the 'pyenv' stage for use by
 402     the main build stage.
 403     """
 404     if len(input_args.venvs) < 1:
 405         raise RuntimeError('No venvs to build...')
 406     if output_stages is None or not isinstance(output_stages, collections.abc.Mapping):
 407         raise RuntimeError('Need a container for output stages.')
 408
 409     # Main Python stage that collects the environments from individual stages.
 410     # We collect the stages individually, rather than chaining them, because the
 411     # copy is a bit slow and wastes local Docker image space for each filesystem
 412     # layer.
 413     pyenv_stage = hpccm.Stage()
 414     pyenv_stage += hpccm.primitives.baseimage(image=base_image_tag(input_args), _as='pyenv')
 415     pyenv_stage += building_blocks['compiler']
 416     pyenv_stage += building_blocks['mpi']
 417     pyenv_stage += hpccm.building_blocks.packages(ospackages=_python_extra_packages)
 418
 419     for version in [StrictVersion(py_ver) for py_ver in sorted(input_args.venvs)]:
 420         stage_name = 'py' + str(version)
 421         stage = hpccm.Stage()
 422         stage += hpccm.primitives.baseimage(image=base_image_tag(input_args), _as=stage_name)
 423         stage += building_blocks['compiler']
 424         stage += building_blocks['mpi']
 425         stage += hpccm.building_blocks.packages(ospackages=_python_extra_packages)
 426
 427         # TODO: Use a non-root user for testing and Python virtual environments.
 428         stage += hpccm.primitives.shell(commands=[
 429             'curl https://pyenv.run | bash',
 430             """echo 'export PYENV_ROOT="$HOME/.pyenv"' >> $HOME/.bashrc""",
 431             """echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> $HOME/.bashrc""",
 432             """echo 'eval "$(pyenv init -)"' >> $HOME/.bashrc""",
 433             """echo 'eval "$(pyenv virtualenv-init -)"' >> $HOME/.bashrc"""])
 434         pyenv = '$HOME/.pyenv/bin/pyenv'
 435         commands = [f'PYTHON_CONFIGURE_OPTS="--enable-shared" {pyenv} install -s {version}']
 436         stage += hpccm.primitives.shell(commands=commands)
 437
 438         commands = prepare_venv(version)
 439         stage += hpccm.primitives.shell(commands=commands)
 440
 441         # TODO: Update user home directory.
 442         pyenv_stage += hpccm.primitives.copy(_from=stage_name, _mkdir=True, src=['/root/'],
 443                                              dest='/root')
 444
 445         # Add the intermediate build stage to the sequence
 446         output_stages[stage_name] = stage
 447
 448     # TODO: If we activate pyenv for login shells, the `global` "version" should be full-featured.
 449     # # `version` should be a system installation or pyenv environment (or pyenv-virtualenv)
 450     # # with the dependencies for all of the Python aspects of CMake-driven builds.
 451     # commands = '{pyenv} global {version}'.format(
 452     #             pyenv=pyenv,
 453     #             version=...)
 454     # pyenv_stage += hpccm.primitives.shell(commands=commands)
 455
 456     # Add the aggregating build stage to the sequence. This allows the main stage to copy
 457     # the files in a single stage, potentially reducing the overall output image size.
 458     output_stages['pyenv'] = pyenv_stage
 459
 460
 461 def add_documentation_dependencies(input_args,
 462                                    output_stages: typing.MutableMapping[str, hpccm.Stage]):
 463     """Add appropriate layers according to doxygen input arguments."""
 464     if input_args.doxygen is None:
 465         return
 466     output_stages['main'] += hpccm.primitives.shell(
 467         commands=['sed -i \'/\"XPS\"/d;/\"PDF\"/d;/\"PS\"/d;/\"EPS\"/d;/disable ghostscript format types/d\' /etc/ImageMagick-6/policy.xml'])
 468     if input_args.doxygen == '1.8.5':
 469         doxygen_commit = 'ed4ed873ab0e7f15116e2052119a6729d4589f7a'
 470         output_stages['main'] += hpccm.building_blocks.generic_autotools(
 471             repository='https://github.com/westes/flex.git',
 472             commit='f7788a9a0ecccdc953ed12043ccb59ca25714018',
 473             prefix='/tmp/install-of-flex',
 474             configure_opts=['--disable-shared'],
 475             preconfigure=['./autogen.sh'])
 476         output_stages['main'] += hpccm.building_blocks.generic_autotools(
 477             repository='https://github.com/doxygen/doxygen.git',
 478             commit=doxygen_commit,
 479             prefix='',
 480             configure_opts=[
 481                 '--flex /tmp/install-of-flex/bin/flex',
 482                 '--static'])
 483     else:
 484         version = input_args.doxygen
 485         archive_name = f'doxygen-{version}.linux.bin.tar.gz'
 486         archive_url = f'https://sourceforge.net/projects/doxygen/files/rel-{version}/{archive_name}'
 487         binary_path = f'doxygen-{version}/bin/doxygen'
 488         commands = [
 489             'mkdir doxygen && cd doxygen',
 490             f'wget {archive_url}',
 491             f'tar xf {archive_name} {binary_path}',
 492             f'cp {binary_path} /usr/local/bin/',
 493             'cd .. && rm -rf doxygen'
 494         ]
 495         output_stages['main'] += hpccm.primitives.shell(commands=commands)
 496
 497
 498 def build_stages(args) -> typing.Iterable[hpccm.Stage]:
 499     """Define and sequence the stages for the recipe corresponding to *args*."""
 500
 501     # A Dockerfile or Singularity recipe can have multiple build stages.
 502     # The main build stage can copy files from previous stages, though only
 503     # the last stage is included in the tagged output image. This means that
 504     # large or expensive sets of build instructions can be isolated in
 505     # local/temporary images, but all of the stages need to be output by this
 506     # script, and need to occur in the correct order, so we create a sequence
 507     # object early in this function.
 508     stages = collections.OrderedDict()
 509
 510     # If we need TSAN or oneAPI support the early build is more complex,
 511     # so that our compiler images don't have all the cruft needed to get those things
 512     # installed.
 513     if args.llvm is not None and args.tsan is not None:
 514         add_tsan_compiler_build_stage(input_args=args, output_stages=stages)
 515     if args.oneapi is not None:
 516         add_oneapi_compiler_build_stage(input_args=args, output_stages=stages)
 517
 518     # Building blocks are chunks of container-builder instructions that can be
 519     # copied to any build stage with the addition operator.
 520     building_blocks = collections.OrderedDict()
 521     building_blocks['base_packages'] = hpccm.building_blocks.packages(
 522         ospackages=_common_packages)
 523
 524     # These are the most expensive and most reusable layers, so we put them first.
 525     building_blocks['compiler'] = get_compiler(args, compiler_build_stage=stages.get('compiler_build'))
 526     building_blocks['mpi'] = get_mpi(args, building_blocks['compiler'])
 527     for i, cmake in enumerate(args.cmake):
 528         building_blocks['cmake' + str(i)] = hpccm.building_blocks.cmake(
 529             eula=True,
 530             prefix=f'/usr/local/cmake-{cmake}',
 531             version=cmake)
 532
 533     # Install additional packages early in the build to optimize Docker build layer cache.
 534     os_packages = list(get_llvm_packages(args)) + get_opencl_packages(args)
 535     if args.doxygen is not None:
 536         os_packages += _docs_extra_packages
 537     if args.oneapi is not None:
 538         os_packages += ['lsb-release']
 539     building_blocks['extra_packages'] = hpccm.building_blocks.packages(
 540         ospackages=os_packages,
 541         apt_ppas=['ppa:intel-opencl/intel-opencl'],
 542         apt_keys=['http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key'],
 543         apt_repositories=['deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main']
 544     )
 545
 546     building_blocks['clfft'] = get_clfft(args)
 547
 548     # Add Python environments to MPI images, only, so we don't have to worry
 549     # about whether to install mpi4py.
 550     if args.mpi is not None and len(args.venvs) > 0:
 551         add_python_stages(building_blocks=building_blocks, input_args=args, output_stages=stages)
 552
 553     # Create the stage from which the targeted image will be tagged.
 554     stages['main'] = hpccm.Stage()
 555
 556     stages['main'] += hpccm.primitives.baseimage(image=base_image_tag(args))
 557     for bb in building_blocks.values():
 558         if bb is not None:
 559             stages['main'] += bb
 560
 561     # We always add Python3 and Pip
 562     stages['main'] += hpccm.building_blocks.python(python3=True, python2=False)
 563
 564     # Add documentation requirements (doxygen and sphinx + misc).
 565     if args.doxygen is not None:
 566         add_documentation_dependencies(args, stages)
 567
 568     if 'pyenv' in stages and stages['pyenv'] is not None:
 569         stages['main'] += hpccm.primitives.copy(_from='pyenv', _mkdir=True, src=['/root/.pyenv/'],
 570                                                 dest='/root/.pyenv')
 571         stages['main'] += hpccm.primitives.copy(_from='pyenv', _mkdir=True, src=['/root/venv/'],
 572                                                 dest='/root/venv')
 573         # TODO: Update user home directory.
 574         # TODO: If we activate pyenv for login shells, the `global` "version" should be full-featured.
 575         # stages['main'] += hpccm.primitives.copy(_from='pyenv', src=['/root/.bashrc'],
 576         #                                         dest='/root/')
 577
 578     # Make sure that `python` resolves to something.
 579     stages['main'] += hpccm.primitives.shell(commands=['test -x /usr/bin/python || '
 580                                                        'update-alternatives --install /usr/bin/python python /usr/bin/python3 1 && '
 581                                                        '/usr/bin/python --version'])
 582
 583     # Note that the list of stages should be sorted in dependency order.
 584     for build_stage in stages.values():
 585         if build_stage is not None:
 586             yield build_stage
 587
 588
 589 if __name__ == '__main__':
 590     args = parser.parse_args()
 591
 592     # Set container specification output format
 593     hpccm.config.set_container_format(args.format)
 594
 595     container_recipe = build_stages(args)
 596
 597     # Output container specification
 598     for stage in container_recipe:
 599         print(stage)