feat: proper archspec detection using archspec-rs (#584)

Implements proper archspec detection using
https://github.com/prefix-dev/archspec-rs which is a port of
https://github.com/archspec/archspec used by `conda`. This opens the
doors to build and use architecture specific packages.

We loose the `__archspec` virtual package for wasm targets because the
archspec standard does not describe these targets.

I set the default archspec for `osx-arm64` to `m1` because I think thats
greatest common denominator for arm based chips on mac.

I also added a subcommand to rattler-bin to print the detected virtual
packages.

On my windows machine:

```
> cargo run -- virtual-packages
__win=0=0
__cuda=12.3=0
__archspec=1=skylake
```

Under WSL:

```
> cargo run -- virtual-packages
__unix=0=0
__linux=5.15.146.1=0
__glibc=2.35=0
__cuda=12.3=0
__archspec=1=skylake
```

@wolfv Would you be able to run this on you mac and report the output?
@ruben-arts Can you try on your machines as well?

You can verify that this is the same as conda by creating an environment
with `conda` and `archspec` and running `conda info`.

Cargo.toml

@@ -24,6 +24,7 @@ lto = true
 
 [workspace.dependencies]
 anyhow = "1.0.80"
+archspec = "0.1.2"
 assert_matches = "1.5.0"
 async-compression = { version = "0.4.6", features = [
     "gzip",

crates/rattler-bin/src/commands/mod.rs

@@ -1 +1,2 @@
 pub mod create;
+pub mod virtual_packages;

crates/rattler-bin/src/commands/virtual_packages.rs

@@ -0,0 +1,12 @@
+use rattler_conda_types::GenericVirtualPackage;
+
+#[derive(Debug, clap::Parser)]
+pub struct Opt {}
+
+pub fn virtual_packages(_opt: Opt) -> anyhow::Result<()> {
+    let virtual_packages = rattler_virtual_packages::VirtualPackage::current()?;
+    for package in virtual_packages {
+        println!("{}", GenericVirtualPackage::from(package.clone()));
+    }
+    Ok(())
+}

crates/rattler-bin/src/main.rs

@@ -38,6 +38,7 @@ struct Opt {
 #[derive(Debug, clap::Subcommand)]
 enum Command {
     Create(commands::create::Opt),
+    VirtualPackages(commands::virtual_packages::Opt),
 }
 
 /// Entry point of the `rattler` cli.
@@ -70,5 +71,6 @@ async fn main() -> anyhow::Result<()> {
     // Dispatch the selected comment
     match opt.command {
         Command::Create(opts) => commands::create::create(opts).await,
+        Command::VirtualPackages(opts) => commands::virtual_packages::virtual_packages(opts),
     }
 }

crates/rattler_virtual_packages/Cargo.toml

@@ -20,6 +20,7 @@ regex = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
+archspec = { workspace = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
 plist = { workspace = true }

crates/rattler_virtual_packages/src/lib.rs

@@ -33,13 +33,16 @@ pub mod libc;
 pub mod linux;
 pub mod osx;
 
+use archspec::cpu::Microarchitecture;
 use once_cell::sync::OnceCell;
 use rattler_conda_types::{GenericVirtualPackage, PackageName, Platform, Version};
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
 
 use crate::osx::ParseOsxVersionError;
 use libc::DetectLibCError;
 use linux::ParseLinuxVersionError;
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// An enum that represents all virtual package types provided by this library.
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
@@ -145,7 +148,7 @@ fn try_detect_virtual_packages() -> Result<Vec<VirtualPackage>, DetectVirtualPac
         result.push(cuda.into());
     }
 
-    if let Some(archspec) = Archspec::from_platform(platform) {
+    if let Some(archspec) = Archspec::current() {
         result.push(archspec.into());
     }
 
@@ -257,40 +260,95 @@ impl From<Cuda> for VirtualPackage {
 }
 
 /// Archspec describes the CPU architecture
-#[derive(Clone, Eq, PartialEq, Hash, Debug, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct Archspec {
-    /// A specification of the architecture family. This could be `x86_64` but it could also include
-    /// the full CPU family.
-    pub spec: String,
+    /// The associated microarchitecture
+    pub spec: Arc<Microarchitecture>,
+}
+
+impl Serialize for Archspec {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.spec.name().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for Archspec {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let name = String::deserialize(deserializer)?;
+        let spec = archspec::cpu::Microarchitecture::known_targets()
+            .get(&name)
+            .cloned()
+            .unwrap_or_else(|| Arc::new(archspec::cpu::Microarchitecture::generic(&name)));
+        Ok(Self { spec })
+    }
+}
+
+impl Hash for Archspec {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.spec.name().hash(state);
+    }
+}
+
+impl PartialEq<Self> for Archspec {
+    fn eq(&self, other: &Self) -> bool {
+        self.spec.name() == other.spec.name()
+    }
+}
+
+impl Eq for Archspec {}
+
+impl From<Arc<Microarchitecture>> for Archspec {
+    fn from(arch: Arc<Microarchitecture>) -> Self {
+        Self { spec: arch }
+    }
 }
 
 impl Archspec {
     /// Returns the current CPU architecture
     pub fn current() -> Option<Self> {
-        Self::from_platform(Platform::current())
+        archspec::cpu::host().ok().map(Into::into)
     }
 
-    /// Returns the CPU architecture for the given platform
+    /// Returns the minimal supported archspec architecture for the given
+    /// platform.
+    #[allow(clippy::match_same_arms)]
     pub fn from_platform(platform: Platform) -> Option<Self> {
-        let archspec = match platform {
+        // The values are taken from the archspec-json library.
+        // See: https://github.com/archspec/archspec-json/blob/master/cpu/microarchitectures.json
+        let archspec_name = match platform {
             Platform::NoArch | Platform::Unknown => return None,
-            Platform::EmscriptenWasm32 | Platform::WasiWasm32 => "wasm32",
+            Platform::EmscriptenWasm32 | Platform::WasiWasm32 => return None,
             Platform::Win32 | Platform::Linux32 => "x86",
             Platform::Win64 | Platform::Osx64 | Platform::Linux64 => "x86_64",
-            Platform::LinuxAarch64 => "aarch64",
-            Platform::LinuxArmV6l => "armv6l",
-            Platform::LinuxArmV7l => "armv7l",
+            Platform::LinuxAarch64 | Platform::LinuxArmV6l | Platform::LinuxArmV7l => "aarch64",
             Platform::LinuxPpc64le => "ppc64le",
             Platform::LinuxPpc64 => "ppc64",
             Platform::LinuxS390X => "s390x",
             Platform::LinuxRiscv32 => "riscv32",
             Platform::LinuxRiscv64 => "riscv64",
-            Platform::WinArm64 | Platform::OsxArm64 => "arm64",
+
+            // TODO: There must be a minimal aarch64 version that windows supports.
+            Platform::WinArm64 => "aarch64",
+
+            // The first every Apple Silicon Macs are based on m1.
+            Platform::OsxArm64 => "m1",
         };
 
-        Some(Self {
-            spec: archspec.into(),
-        })
+        Some(
+            archspec::cpu::Microarchitecture::known_targets()
+                .get(archspec_name)
+                .cloned()
+                .unwrap_or_else(|| {
+                    Arc::new(archspec::cpu::Microarchitecture::generic(archspec_name))
+                })
+                .into(),
+        )
     }
 }
 
@@ -299,7 +357,7 @@ impl From<Archspec> for GenericVirtualPackage {
         GenericVirtualPackage {
             name: PackageName::new_unchecked("__archspec"),
             version: Version::major(1),
-            build_string: archspec.spec,
+            build_string: archspec.spec.name().to_string(),
         }
     }
 }