spack.operating_systems package

Submodules

spack.operating_systems.cray_backend module

class spack.operating_systems.cray_backend.CrayBackend[source]

Bases: LinuxDistro

Compute Node Linux (CNL) is the operating system used for the Cray XC series super computers. It is a very stripped down version of GNU/Linux. Any compilers found through this operating system will be used with modules. If updated, user must make sure that version and name are updated to indicate that OS has been upgraded (or downgraded)

arguments_to_detect_version_fn(paths)[source]
detect_version(detect_version_args)[source]
make_compilers(compiler_id, paths)[source]
spack.operating_systems.cray_backend.read_cle_release_file()[source]

Read the CLE release file and return a dict with its attributes.

This file is present on newer versions of Cray.

The release file looks something like this:

RELEASE=6.0.UP07
BUILD=6.0.7424
...

The dictionary we produce looks like this:

{
  "RELEASE": "6.0.UP07",
  "BUILD": "6.0.7424",
  ...
}
Returns

dictionary of release attributes

Return type

dict

spack.operating_systems.cray_backend.read_clerelease_file()[source]

Read the CLE release file and return the Cray OS version.

This file is present on older versions of Cray.

The release file looks something like this:

5.2.UP04
Returns

the Cray OS version

Return type

str

spack.operating_systems.cray_frontend module

class spack.operating_systems.cray_frontend.CrayFrontend[source]

Bases: LinuxDistro

Represents OS that runs on login and service nodes of the Cray platform. It acts as a regular Linux without Cray-specific modules and compiler wrappers.

property compiler_search_paths

Calls the default function but unloads Cray’s programming environments first.

This prevents from detecting Cray compiler wrappers and avoids possible false detections.

spack.operating_systems.cray_frontend.unload_programming_environment()[source]

Context manager that unloads Cray Programming Environments.

spack.operating_systems.linux_distro module

class spack.operating_systems.linux_distro.LinuxDistro[source]

Bases: OperatingSystem

This class will represent the autodetected operating system for a Linux System. Since there are many different flavors of Linux, this class will attempt to encompass them all through autodetection using the python module platform and the method platform.dist()

spack.operating_systems.linux_distro.kernel_version()[source]

Return the kernel version as a Version object. Note that the kernel version is distinct from OS and/or distribution versions. For instance: >>> external.distro.id() ‘centos’ >>> external.distro.version() ‘7’ >>> platform.release() ‘5.10.84+’

spack.operating_systems.mac_os module

class spack.operating_systems.mac_os.MacOs[source]

Bases: OperatingSystem

This class represents the macOS operating system. This will be auto detected using the python platform.mac_ver. The macOS platform will be represented using the major version operating system name, i.e el capitan, yosemite…etc.

spack.operating_systems.mac_os.macos_cltools_version()[source]

Find the last installed version of the CommandLineTools.

The CLT version might only affect the build if it’s selected as the macOS SDK path.

spack.operating_systems.mac_os.macos_sdk_path()[source]

Return path to the active macOS SDK.

spack.operating_systems.mac_os.macos_sdk_version()[source]

Return the version of the active macOS SDK.

The SDK version usually corresponds to the installed Xcode version and can affect how some packages (especially those that use the GUI) can fail. This information should somehow be embedded into the future “compilers are dependencies” feature.

The macOS deployment target cannot be greater than the SDK version, but usually it can be at least a few versions less.

spack.operating_systems.mac_os.macos_version()[source]

Get the current macOS version as a version object.

This has three mechanisms for determining the macOS version, which is used for spack identification (the os in the spec’s arch) and indirectly for setting the value of MACOSX_DEPLOYMENT_TARGET, which affects the minos value of the LC_BUILD_VERSION macho header. Mixing minos values can lead to lots of linker warnings, and using a consistent version (pinned to the major OS version) allows distribution across clients that might be slightly behind.

The version determination is made with three mechanisms in decreasing priority:

  1. The MACOSX_DEPLOYMENT_TARGET variable overrides the actual operating system version, just like the value can be used to build for older macOS targets on newer systems. Spack currently will truncate this value when building packages, but at least the major version will be the same.

  2. The system sw_vers command reports the actual operating system version.

  3. The Python platform.mac_ver function is a fallback if the operating system identification fails, because some Python versions and/or installations report the OS on which Python was built rather than the one on which it is running.

spack.operating_systems.windows_os module

class spack.operating_systems.windows_os.WindowsOs[source]

Bases: OperatingSystem

This class represents the Windows operating system. This will be auto detected using the python platform.win32_ver() once we have a python setup that runs natively. The Windows platform will be represented using the major version operating system number, e.g. 10.

comp_search_paths = []
root = None
vs_install_paths = []
spack.operating_systems.windows_os.windows_version()[source]

temporary workaround to return a Windows version as a Version object

Module contents

class spack.operating_systems.CrayBackend[source]

Bases: LinuxDistro

Compute Node Linux (CNL) is the operating system used for the Cray XC series super computers. It is a very stripped down version of GNU/Linux. Any compilers found through this operating system will be used with modules. If updated, user must make sure that version and name are updated to indicate that OS has been upgraded (or downgraded)

arguments_to_detect_version_fn(paths)[source]
detect_version(detect_version_args)[source]
make_compilers(compiler_id, paths)[source]
class spack.operating_systems.CrayFrontend[source]

Bases: LinuxDistro

Represents OS that runs on login and service nodes of the Cray platform. It acts as a regular Linux without Cray-specific modules and compiler wrappers.

property compiler_search_paths

Calls the default function but unloads Cray’s programming environments first.

This prevents from detecting Cray compiler wrappers and avoids possible false detections.

class spack.operating_systems.LinuxDistro[source]

Bases: OperatingSystem

This class will represent the autodetected operating system for a Linux System. Since there are many different flavors of Linux, this class will attempt to encompass them all through autodetection using the python module platform and the method platform.dist()

class spack.operating_systems.MacOs[source]

Bases: OperatingSystem

This class represents the macOS operating system. This will be auto detected using the python platform.mac_ver. The macOS platform will be represented using the major version operating system name, i.e el capitan, yosemite…etc.

class spack.operating_systems.OperatingSystem(name, version)[source]

Bases: object

Base class for all the Operating Systems.

On a multiple architecture machine, the architecture spec field can be set to build a package against any target and operating system that is present on the platform. On Cray platforms or any other architecture that has different front and back end environments, the operating system will determine the method of compiler detection.

There are two different types of compiler detection:

  1. Through the $PATH env variable (front-end detection)

  2. Through the module system. (back-end detection)

Depending on which operating system is specified, the compiler will be detected using one of those methods.

For platforms such as linux and darwin, the operating system is autodetected.

to_dict()[source]
class spack.operating_systems.WindowsOs[source]

Bases: OperatingSystem

This class represents the Windows operating system. This will be auto detected using the python platform.win32_ver() once we have a python setup that runs natively. The Windows platform will be represented using the major version operating system number, e.g. 10.

comp_search_paths = []
root = None
vs_install_paths = []