def test_prefix_join(): """Test prefix join ``prefix.join(...)``""" prefix = Prefix('/usr') a1 = prefix.join('a_{0}'.format(1)).lib64 a2 = prefix.join('a-{0}'.format(1)).lib64 a3 = prefix.join('a.{0}'.format(1)).lib64 assert a1 == '/usr/a_1/lib64' assert a2 == '/usr/a-1/lib64' assert a3 == '/usr/a.1/lib64' assert isinstance(a1, Prefix) assert isinstance(a2, Prefix) assert isinstance(a3, Prefix) p1 = prefix.bin.join('executable.sh') p2 = prefix.share.join('pkg-config').join('foo.pc') p3 = prefix.join('dashed-directory').foo assert p1 == '/usr/bin/executable.sh' assert p2 == '/usr/share/pkg-config/foo.pc' assert p3 == '/usr/dashed-directory/foo' assert isinstance(p1, Prefix) assert isinstance(p2, Prefix) assert isinstance(p3, Prefix)
def test_prefix_join(): """Test prefix join ``prefix.join(...)``""" prefix = Prefix(os.sep + 'usr') a1 = prefix.join('a_{0}'.format(1)).lib64 a2 = prefix.join('a-{0}'.format(1)).lib64 a3 = prefix.join('a.{0}'.format(1)).lib64 assert a1 == os.sep + os.path.join('usr', 'a_1', 'lib64') assert a2 == os.sep + os.path.join('usr', 'a-1', 'lib64') assert a3 == os.sep + os.path.join('usr', 'a.1', 'lib64') assert isinstance(a1, Prefix) assert isinstance(a2, Prefix) assert isinstance(a3, Prefix) p1 = prefix.bin.join('executable.sh') p2 = prefix.share.join('pkg-config').join('foo.pc') p3 = prefix.join('dashed-directory').foo assert p1 == os.sep + os.path.join('usr', 'bin', 'executable.sh') assert p2 == os.sep + os.path.join('usr', 'share', 'pkg-config', 'foo.pc') assert p3 == os.sep + os.path.join('usr', 'dashed-directory', 'foo') assert isinstance(p1, Prefix) assert isinstance(p2, Prefix) assert isinstance(p3, Prefix)
def test_string_like_behavior(): """Test string-like behavior of the prefix object""" prefix = Prefix('/usr') assert prefix == '/usr' assert isinstance(prefix, str) assert prefix + '/bin' == '/usr/bin' assert '--prefix=%s' % prefix == '--prefix=/usr' assert '--prefix={0}'.format(prefix) == '--prefix=/usr' assert prefix.find('u', 1) assert prefix.upper() == '/USR' assert prefix.lstrip('/') == 'usr'
def setup_dependent_build_environment(self, env, dependent_spec): prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'compilers')) env.prepend_path('LIBRARY_PATH', prefix.lib) env.prepend_path('LD_LIBRARY_PATH', prefix.lib) if '+mpi' in self.spec: mpi_prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'comm_libs', 'mpi')) env.prepend_path('LD_LIBRARY_PATH', mpi_prefix.lib)
def test_prefix_attributes(): """Test normal prefix attributes like ``prefix.bin``""" prefix = Prefix('/usr') assert prefix.bin == '/usr/bin' assert prefix.lib == '/usr/lib' assert prefix.include == '/usr/include'
def get_rocm_prefix_info(self): # External packages in Spack do not currently contain dependency # information. External installations of hip therefore must compute # necessary paths to other rocm components by relative paths. This # assumes all components are installed under a single umbrella # directory. Manual edits to `fallback_path` may be necessary if this # assumption does not hold. if self.spec.external: # typically, self.spec.prefix is /opt/rocm/hip, so fallback_path # will be /opt/rocm. The rocminfo executable is usually # found at /opt/rocm/bin/rocminfo. fallback_prefix = Prefix(os.path.dirname(self.spec.prefix)) if not os.path.isdir(fallback_prefix): msg = "Could not determine prefix for other rocm components\n" msg += "Either report a bug at github.com/spack/spack or " msg += "manually edit fallback_prefix in the package file as " msg += "a workaround." raise RuntimeError(msg) return { 'llvm-amdgpu': fallback_prefix.llvm, 'hsa-rocr-dev': fallback_prefix.hsa, 'rocminfo': fallback_prefix.bin, 'rocm-device-libs': fallback_prefix, } else: return dict((name, self.spec[name].prefix) for name in ('llvm-amdgpu', 'hsa-rocr-dev', 'rocminfo', 'rocm-device-libs'))
def test_prefix_attributes(): """Test normal prefix attributes like ``prefix.bin``""" prefix = Prefix(os.sep + 'usr') assert prefix.bin == os.sep + os.path.join('usr', 'bin') assert prefix.lib == os.sep + os.path.join('usr', 'lib') assert prefix.include == os.sep + os.path.join('usr', 'include')
def setup_dependent_package(self, module, dep_spec): # Intel comes with 2 different flavors of MPI wrappers: # # * mpiicc, mpiicpc, and mpifort are hardcoded to wrap around # the Intel compilers. # * mpicc, mpicxx, mpif90, and mpif77 allow you to set which # compilers to wrap using I_MPI_CC and friends. By default, # wraps around the GCC compilers. # # In theory, these should be equivalent as long as I_MPI_CC # and friends are set to point to the Intel compilers, but in # practice, mpicc fails to compile some applications while # mpiicc works. mpiicc_list = find(self.prefix, 'mpiicc', recursive=True) assert len(mpiicc_list) == 1 bindir = Prefix(os.path.dirname(mpiicc_list.pop())) if self.compiler.name == 'intel': self.spec.mpicc = bindir.mpiicc self.spec.mpicxx = bindir.mpiicpc self.spec.mpifc = bindir.mpiifort self.spec.mpif77 = bindir.mpiifort else: self.spec.mpicc = bindir.mpicc self.spec.mpicxx = bindir.mpicxx self.spec.mpifc = bindir.mpif90 self.spec.mpif77 = bindir.mpif77
def setup_run_environment(self, env): prefix = Prefix(join_path(self.prefix, 'linux86-64', self.version)) env.prepend_path('PATH', prefix.bin) env.prepend_path('MANPATH', prefix.man) env.prepend_path('LD_LIBRARY_PATH', prefix.lib) env.set('CC', join_path(prefix.bin, 'pgcc')) env.set('CXX', join_path(prefix.bin, 'pgc++')) env.set('F77', join_path(prefix.bin, 'pgfortran')) env.set('FC', join_path(prefix.bin, 'pgfortran'))
def setup_dependent_package(self, module, dependent_spec): if '+mpi' in self.spec or self.provides('mpi'): mpi_prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'comm_libs', 'mpi')) self.spec.mpicc = join_path(mpi_prefix.bin, 'mpicc') self.spec.mpicxx = join_path(mpi_prefix.bin, 'mpicxx') self.spec.mpif77 = join_path(mpi_prefix.bin, 'mpif77') self.spec.mpifc = join_path(mpi_prefix.bin, 'mpif90')
def test_multilevel_attributes(): """Test attributes of attributes, like ``prefix.share.man``""" prefix = Prefix(os.sep + 'usr' + os.sep) assert prefix.share.man == os.sep + os.path.join('usr', 'share', 'man') assert prefix.man.man8 == os.sep + os.path.join('usr', 'man', 'man8') assert prefix.foo.bar.baz == os.sep + os.path.join('usr', 'foo', 'bar', 'baz') share = prefix.share assert isinstance(share, Prefix) assert share.man == os.sep + os.path.join('usr', 'share', 'man')
def home(self): """Most of the time, ``PYTHONHOME`` is simply ``spec['python'].prefix``. However, if the user is using an externally installed python, it may be symlinked. For example, Homebrew installs python in ``/usr/local/Cellar/python/2.7.12_2`` and symlinks it to ``/usr/local``. Users may not know the actual installation directory and add ``/usr/local`` to their ``packages.yaml`` unknowingly. Query the python executable to determine exactly where it is installed.""" prefix = self.get_config_var('prefix') return Prefix(prefix)
def setup_run_environment(self, env): prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'compilers')) env.set('CC', join_path(prefix.bin, 'nvc')) env.set('CXX', join_path(prefix.bin, 'nvc++')) env.set('F77', join_path(prefix.bin, 'nvfortran')) env.set('FC', join_path(prefix.bin, 'nvfortran')) env.prepend_path('PATH', prefix.bin) env.prepend_path('LIBRARY_PATH', prefix.lib) env.prepend_path('LD_LIBRARY_PATH', prefix.lib) env.prepend_path('MANPATH', prefix.man) if '+mpi' in self.spec: mpi_prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'comm_libs', 'mpi')) env.prepend_path('PATH', mpi_prefix.bin) env.prepend_path('LD_LIBRARY_PATH', mpi_prefix.lib)
def test_multilevel_attributes(): """Test attributes of attributes, like ``prefix.share.man``""" prefix = Prefix('/usr/') assert prefix.share.man == '/usr/share/man' assert prefix.man.man8 == '/usr/man/man8' assert prefix.foo.bar.baz == '/usr/foo/bar/baz' share = prefix.share assert isinstance(share, Prefix) assert share.man == '/usr/share/man'
def setup_environment(self, spack_env, run_env): prefix = Prefix(join_path(self.prefix, 'linux86-64', self.version)) run_env.set('CC', join_path(prefix.bin, 'pgcc')) run_env.set('CXX', join_path(prefix.bin, 'pgc++')) run_env.set('F77', join_path(prefix.bin, 'pgfortran')) run_env.set('FC', join_path(prefix.bin, 'pgfortran')) run_env.set('PATH', prefix.bin) run_env.set('CPATH', prefix.include) run_env.set('LIBRARY_PATH', prefix.lib) run_env.set('LD_LIBRARY_PATH', prefix.lib) run_env.set('MANPATH', prefix.man)
def setup_environment(self, spack_env, run_env): # FIXME - generalize arch prefix = Prefix(self.true_prefix) run_env.set('CC', join_path(prefix.bin, 'pgcc')) run_env.set('CXX', join_path(prefix.bin, 'pgc++')) run_env.set('F77', join_path(prefix.bin, 'pgfortran')) run_env.set('FC', join_path(prefix.bin, 'pgfortran')) run_env.prepend_path('PATH', prefix.bin) run_env.prepend_path('CPATH', prefix.include) run_env.prepend_path('LIBRARY_PATH', prefix.lib) run_env.prepend_path('LD_LIBRARY_PATH', prefix.lib) run_env.prepend_path('MANPATH', prefix.man)
def libs(self): prefix = Prefix(join_path(self.prefix, 'Linux_%s' % self.spec.target.family, self.version, 'compilers')) libs = [] if '+blas' in self.spec: libs.append('libblas') if '+lapack' in self.spec: libs.append('liblapack') libs.append('libnvf') return find_libraries(libs, root=prefix, recursive=True)
def home(self): """Most of the time, ``PYTHONHOME`` is simply ``spec['python'].prefix``. However, if the user is using an externally installed python, it may be symlinked. For example, Homebrew installs python in ``/usr/local/Cellar/python/2.7.12_2`` and symlinks it to ``/usr/local``. Users may not know the actual installation directory and add ``/usr/local`` to their ``packages.yaml`` unknowingly. Query the python executable to determine exactly where it is installed. Fall back on ``spec['python'].prefix`` if that doesn't work.""" dag_hash = self.spec.dag_hash() if dag_hash not in self._homes: try: prefix = self.get_config_var('prefix') except ProcessError: prefix = self.prefix self._homes[dag_hash] = Prefix(prefix) return self._homes[dag_hash]
def setup_run_environment(self, env): prefix = Prefix(join_path(self.prefix, 'linux86-64', self.version)) env.prepend_path('PATH', prefix.bin) env.prepend_path('MANPATH', prefix.man) env.prepend_path('LD_LIBRARY_PATH', prefix.lib) env.set('CC', join_path(prefix.bin, 'pgcc')) env.set('CXX', join_path(prefix.bin, 'pgc++')) env.set('F77', join_path(prefix.bin, 'pgfortran')) env.set('FC', join_path(prefix.bin, 'pgfortran')) if '+mpi' in self.spec: ompi_dir = os.listdir(prefix.mpi)[0] env.prepend_path('PATH', join_path(prefix.mpi, ompi_dir, 'bin')) env.prepend_path('LD_LIBRARY_PATH', join_path(prefix.mpi, ompi_dir, 'lib')) env.prepend_path('C_INCLUDE_PATH', join_path(prefix.mpi, ompi_dir, 'include')) env.prepend_path('MANPATH', join_path(prefix.mpi, ompi_dir, 'share/man'))
def home(self): """Most of the time, ``JAVA_HOME`` is simply ``spec['java'].prefix``. However, if the user is using an externally installed JDK, it may be symlinked. For example, on macOS, the ``java`` executable can be found in ``/usr/bin``, but ``JAVA_HOME`` is actually ``/Library/Java/JavaVirtualMachines/jdk-10.0.1.jdk/Contents/Home``. Users may not know the actual installation directory and add ``/usr`` to their ``packages.yaml`` unknowingly. Run ``java_home`` if it exists to determine exactly where it is installed. Specify which version we are expecting in case multiple Java versions are installed. See ``man java_home`` for more details.""" prefix = self.prefix java_home = prefix.libexec.java_home if os.path.exists(java_home): java_home = Executable(java_home) version = str(self.version.up_to(2)) prefix = java_home('--version', version, output=str).strip() prefix = Prefix(prefix) return prefix
def get_paths(self): if self.spec.external: # For external packages we only assume the `hip` prefix is known, # because spack does not set prefixes of dependencies of externals. # We assume self.spec.prefix is /opt/rocm-x.y.z/hip and rocm has a # default installation with everything installed under # /opt/rocm-x.y.z rocm_prefix = Prefix(os.path.dirname(self.spec.prefix)) if not os.path.isdir(rocm_prefix): msg = "Could not determine prefix for other rocm components\n" msg += "Either report a bug at github.com/spack/spack or " msg += "manually edit rocm_prefix in the package file as " msg += "a workaround." raise RuntimeError(msg) paths = { 'rocm-path': rocm_prefix, 'llvm-amdgpu': rocm_prefix.llvm, 'hsa-rocr-dev': rocm_prefix.hsa, 'rocminfo': rocm_prefix, 'rocm-device-libs': rocm_prefix } else: paths = { 'rocm-path': self.spec.prefix, 'llvm-amdgpu': self.spec['llvm-amdgpu'].prefix, 'hsa-rocr-dev': self.spec['hsa-rocr-dev'].prefix, 'rocminfo': self.spec['rocminfo'].prefix, 'rocm-device-libs': self.spec['rocm-device-libs'].prefix } # `device_lib_path` is the path to the bitcode directory if '@:3.8.0' in self.spec: paths['device_lib_path'] = paths['rocm-device-libs'].lib else: paths['device_lib_path'] = paths['rocm-device-libs'].amdgcn.bitcode return paths
def __init__(self, name, prefix): self.name = name self.prefix = Prefix(prefix) self.spec = FakeSpec(self)