Split platform detection code into a dedicated uv-platform crate (#14918)

In service of some subsequent work...

Author: zanieb

Cargo.lock

@@ -49,6 +49,7 @@ uv-once-map = { path = "crates/uv-once-map" }
 uv-options-metadata = { path = "crates/uv-options-metadata" }
 uv-pep440 = { path = "crates/uv-pep440", features = ["tracing", "rkyv", "version-ranges"] }
 uv-pep508 = { path = "crates/uv-pep508", features = ["non-pep508-extensions"] }
+uv-platform = { path = "crates/uv-platform" }
 uv-platform-tags = { path = "crates/uv-platform-tags" }
 uv-publish = { path = "crates/uv-publish" }
 uv-pypi-types = { path = "crates/uv-pypi-types" }

Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "uv-platform"
+version = "0.0.1"
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+
+[lib]
+doctest = false
+
+[lints]
+workspace = true
+
+[dependencies]
+uv-static = { workspace = true }
+uv-fs = { workspace = true }
+uv-platform-tags = { workspace = true }
+
+fs-err = { workspace = true }
+goblin = { workspace = true }
+regex = { workspace = true }
+target-lexicon = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+procfs = { workspace = true }
+
+[dev-dependencies]
+indoc = { workspace = true }

crates/uv-platform/Cargo.toml

@@ -0,0 +1,249 @@
+use crate::Error;
+use std::fmt::Display;
+use std::str::FromStr;
+use std::{cmp, fmt};
+
+/// Architecture variants, e.g., with support for different instruction sets
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash, Ord, PartialOrd)]
+pub enum ArchVariant {
+    /// Targets 64-bit Intel/AMD CPUs newer than Nehalem (2008).
+    /// Includes SSE3, SSE4 and other post-2003 CPU instructions.
+    V2,
+    /// Targets 64-bit Intel/AMD CPUs newer than Haswell (2013) and Excavator (2015).
+    /// Includes AVX, AVX2, MOVBE and other newer CPU instructions.
+    V3,
+    /// Targets 64-bit Intel/AMD CPUs with AVX-512 instructions (post-2017 Intel CPUs).
+    /// Many post-2017 Intel CPUs do not support AVX-512.
+    V4,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
+pub struct Arch {
+    pub(crate) family: target_lexicon::Architecture,
+    pub(crate) variant: Option<ArchVariant>,
+}
+
+impl Ord for Arch {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        if self.family == other.family {
+            return self.variant.cmp(&other.variant);
+        }
+
+        // For the time being, manually make aarch64 windows disfavored
+        // on its own host platform, because most packages don't have wheels for
+        // aarch64 windows, making emulation more useful than native execution!
+        //
+        // The reason we do this in "sorting" and not "supports" is so that we don't
+        // *refuse* to use an aarch64 windows pythons if they happen to be installed
+        // and nothing else is available.
+        //
+        // Similarly if someone manually requests an aarch64 windows install, we
+        // should respect that request (this is the way users should "override"
+        // this behaviour).
+        let preferred = if cfg!(all(windows, target_arch = "aarch64")) {
+            Arch {
+                family: target_lexicon::Architecture::X86_64,
+                variant: None,
+            }
+        } else {
+            // Prefer native architectures
+            Arch::from_env()
+        };
+
+        match (
+            self.family == preferred.family,
+            other.family == preferred.family,
+        ) {
+            (true, true) => unreachable!(),
+            (true, false) => cmp::Ordering::Less,
+            (false, true) => cmp::Ordering::Greater,
+            (false, false) => {
+                // Both non-preferred, fallback to lexicographic order
+                self.family.to_string().cmp(&other.family.to_string())
+            }
+        }
+    }
+}
+
+impl PartialOrd for Arch {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Arch {
+    pub fn new(family: target_lexicon::Architecture, variant: Option<ArchVariant>) -> Self {
+        Self { family, variant }
+    }
+
+    pub fn from_env() -> Self {
+        Self {
+            family: target_lexicon::HOST.architecture,
+            variant: None,
+        }
+    }
+
+    /// Does the current architecture support running the other?
+    ///
+    /// When the architecture is equal, this is always true. Otherwise, this is true if the
+    /// architecture is transparently emulated or is a microarchitecture with worse performance
+    /// characteristics.
+    pub fn supports(self, other: Self) -> bool {
+        if self == other {
+            return true;
+        }
+
+        // TODO: Implement `variant` support checks
+
+        // Windows ARM64 runs emulated x86_64 binaries transparently
+        // Similarly, macOS aarch64 runs emulated x86_64 binaries transparently if you have Rosetta
+        // installed. We don't try to be clever and check if that's the case here, we just assume
+        // that if x86_64 distributions are available, they're usable.
+        if (cfg!(windows) || cfg!(target_os = "macos"))
+            && matches!(self.family, target_lexicon::Architecture::Aarch64(_))
+        {
+            return other.family == target_lexicon::Architecture::X86_64;
+        }
+
+        false
+    }
+
+    pub fn family(&self) -> target_lexicon::Architecture {
+        self.family
+    }
+
+    pub fn is_arm(&self) -> bool {
+        matches!(self.family, target_lexicon::Architecture::Arm(_))
+    }
+}
+
+impl Display for Arch {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.family {
+            target_lexicon::Architecture::X86_32(target_lexicon::X86_32Architecture::I686) => {
+                write!(f, "x86")?;
+            }
+            inner => write!(f, "{inner}")?,
+        }
+        if let Some(variant) = self.variant {
+            write!(f, "_{variant}")?;
+        }
+        Ok(())
+    }
+}
+
+impl FromStr for Arch {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        fn parse_family(s: &str) -> Result<target_lexicon::Architecture, Error> {
+            let inner = match s {
+                // Allow users to specify "x86" as a shorthand for the "i686" variant, they should not need
+                // to specify the exact architecture and this variant is what we have downloads for.
+                "x86" => {
+                    target_lexicon::Architecture::X86_32(target_lexicon::X86_32Architecture::I686)
+                }
+                _ => target_lexicon::Architecture::from_str(s)
+                    .map_err(|()| Error::UnknownArch(s.to_string()))?,
+            };
+            if matches!(inner, target_lexicon::Architecture::Unknown) {
+                return Err(Error::UnknownArch(s.to_string()));
+            }
+            Ok(inner)
+        }
+
+        // First check for a variant
+        if let Some((Ok(family), Ok(variant))) = s
+            .rsplit_once('_')
+            .map(|(family, variant)| (parse_family(family), ArchVariant::from_str(variant)))
+        {
+            // We only support variants for `x86_64` right now
+            if !matches!(family, target_lexicon::Architecture::X86_64) {
+                return Err(Error::UnsupportedVariant(
+                    variant.to_string(),
+                    family.to_string(),
+                ));
+            }
+            return Ok(Self {
+                family,
+                variant: Some(variant),
+            });
+        }
+
+        let family = parse_family(s)?;
+
+        Ok(Self {
+            family,
+            variant: None,
+        })
+    }
+}
+
+impl FromStr for ArchVariant {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "v2" => Ok(Self::V2),
+            "v3" => Ok(Self::V3),
+            "v4" => Ok(Self::V4),
+            _ => Err(()),
+        }
+    }
+}
+
+impl Display for ArchVariant {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::V2 => write!(f, "v2"),
+            Self::V3 => write!(f, "v3"),
+            Self::V4 => write!(f, "v4"),
+        }
+    }
+}
+
+impl From<&uv_platform_tags::Arch> for Arch {
+    fn from(value: &uv_platform_tags::Arch) -> Self {
+        match value {
+            uv_platform_tags::Arch::Aarch64 => Arch::new(
+                target_lexicon::Architecture::Aarch64(target_lexicon::Aarch64Architecture::Aarch64),
+                None,
+            ),
+            uv_platform_tags::Arch::Armv5TEL => Arch::new(
+                target_lexicon::Architecture::Arm(target_lexicon::ArmArchitecture::Armv5te),
+                None,
+            ),
+            uv_platform_tags::Arch::Armv6L => Arch::new(
+                target_lexicon::Architecture::Arm(target_lexicon::ArmArchitecture::Armv6),
+                None,
+            ),
+            uv_platform_tags::Arch::Armv7L => Arch::new(
+                target_lexicon::Architecture::Arm(target_lexicon::ArmArchitecture::Armv7),
+                None,
+            ),
+            uv_platform_tags::Arch::S390X => Arch::new(target_lexicon::Architecture::S390x, None),
+            uv_platform_tags::Arch::Powerpc => {
+                Arch::new(target_lexicon::Architecture::Powerpc, None)
+            }
+            uv_platform_tags::Arch::Powerpc64 => {
+                Arch::new(target_lexicon::Architecture::Powerpc64, None)
+            }
+            uv_platform_tags::Arch::Powerpc64Le => {
+                Arch::new(target_lexicon::Architecture::Powerpc64le, None)
+            }
+            uv_platform_tags::Arch::X86 => Arch::new(
+                target_lexicon::Architecture::X86_32(target_lexicon::X86_32Architecture::I686),
+                None,
+            ),
+            uv_platform_tags::Arch::X86_64 => Arch::new(target_lexicon::Architecture::X86_64, None),
+            uv_platform_tags::Arch::LoongArch64 => {
+                Arch::new(target_lexicon::Architecture::LoongArch64, None)
+            }
+            uv_platform_tags::Arch::Riscv64 => Arch::new(
+                target_lexicon::Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64),
+                None,
+            ),
+            uv_platform_tags::Arch::Wasm32 => Arch::new(target_lexicon::Architecture::Wasm32, None),
+        }
+    }
+}

crates/uv-platform/src/arch.rs

@@ -1,6 +1,6 @@
 //! Fetches CPU information.
 
-use anyhow::Error;
+use std::io::Error;
 
 #[cfg(target_os = "linux")]
 use procfs::{CpuInfo, Current};
@@ -14,7 +14,7 @@ use procfs::{CpuInfo, Current};
 /// More information on this can be found in the [Debian ARM Hard Float Port documentation](https://wiki.debian.org/ArmHardFloatPort#VFP).
 #[cfg(target_os = "linux")]
 pub(crate) fn detect_hardware_floating_point_support() -> Result<bool, Error> {
-    let cpu_info = CpuInfo::current()?;
+    let cpu_info = CpuInfo::current().map_err(Error::other)?;
     if let Some(features) = cpu_info.fields.get("Features") {
         if features.contains("vfp") {
             return Ok(true); // "vfp" found: hard-float (gnueabihf) detected

crates/uv-python/src/cpuinfo.rs renamed to crates/uv-platform/src/cpuinfo.rs

@@ -0,0 +1,26 @@
+//! Platform detection for operating system, architecture, and libc.
+
+use thiserror::Error;
+
+pub use crate::arch::{Arch, ArchVariant};
+pub use crate::libc::{Libc, LibcDetectionError, LibcVersion};
+pub use crate::os::Os;
+
+mod arch;
+mod cpuinfo;
+mod libc;
+mod os;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Unknown operating system: {0}")]
+    UnknownOs(String),
+    #[error("Unknown architecture: {0}")]
+    UnknownArch(String),
+    #[error("Unknown libc environment: {0}")]
+    UnknownLibc(String),
+    #[error("Unsupported variant `{0}` for architecture `{1}`")]
+    UnsupportedVariant(String, String),
+    #[error(transparent)]
+    LibcDetectionError(#[from] crate::libc::LibcDetectionError),
+}