Create hyperactor_named crate

Summary: We need to make `hyperactor_named` it's own crate to break a circular dependency

Differential Revision: D87941210

Author: thomasywang

hyperactor/Cargo.toml

@@ -56,6 +56,7 @@ futures = { version = "0.3.31", features = ["async-await", "compat"] }
 hostname = "0.3"
 humantime = "2.1"
 hyperactor_macros = { version = "0.0.0", path = "../hyperactor_macros" }
+hyperactor_named = { version = "0.0.0", path = "../hyperactor_named" }
 hyperactor_telemetry = { version = "0.0.0", path = "../hyperactor_telemetry" }
 indenter = "0.3.3"
 inventory = "0.3.21"

hyperactor/src/data.rs

@@ -16,53 +16,15 @@ use std::io::Cursor;
 use std::sync::LazyLock;
 
 use enum_as_inner::EnumAsInner;
+pub use hyperactor_named::Named;
+pub use hyperactor_named::intern_typename;
 use serde::Deserialize;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 
 use crate as hyperactor;
 use crate::config;
 
-/// A [`Named`] type is a type that has a globally unique name.
-pub trait Named: Sized + 'static {
-    /// The globally unique type name for the type.
-    /// This should typically be the fully qualified Rust name of the type.
-    fn typename() -> &'static str;
-
-    /// A globally unique hash for this type.
-    /// TODO: actually enforce perfect hashing
-    fn typehash() -> u64 {
-        // The `Named` macro overrides this implementation with one that
-        // memoizes the hash.
-        cityhasher::hash(Self::typename())
-    }
-
-    /// The TypeId for this type. TypeIds are unique only within a binary,
-    /// and should not be used for global identification.
-    fn typeid() -> TypeId {
-        TypeId::of::<Self>()
-    }
-
-    /// The globally unique port for this type. Typed ports are in the range
-    /// of 1<<63..1<<64-1.
-    fn port() -> u64 {
-        Self::typehash() | (1 << 63)
-    }
-
-    /// If the named type is an enum, this returns the name of the arm
-    /// of the value self.
-    fn arm(&self) -> Option<&'static str> {
-        None
-    }
-
-    /// An unsafe version of 'arm', accepting a pointer to the value,
-    /// for use in type-erased settings.
-    unsafe fn arm_unchecked(self_: *const ()) -> Option<&'static str> {
-        // SAFETY: This isn't safe. We're passing it on.
-        unsafe { &*(self_ as *const Self) }.arm()
-    }
-}
-
 #[doc(hidden)]
 /// Dump trait for Named types that are also serializable/deserializable.
 /// This is a utility used by [`Serialized::dump`], and is not intended
@@ -79,140 +41,6 @@ impl<T: Named + Serialize + for<'de> Deserialize<'de>> NamedDumpable for T {
     }
 }
 
-macro_rules! impl_basic {
-    ($t:ty) => {
-        impl Named for $t {
-            fn typename() -> &'static str {
-                stringify!($t)
-            }
-        }
-    };
-}
-
-impl_basic!(());
-impl_basic!(bool);
-impl_basic!(i8);
-impl_basic!(u8);
-impl_basic!(i16);
-impl_basic!(u16);
-impl_basic!(i32);
-impl_basic!(u32);
-impl_basic!(i64);
-impl_basic!(u64);
-impl_basic!(i128);
-impl_basic!(u128);
-impl_basic!(isize);
-impl_basic!(usize);
-impl_basic!(f32);
-impl_basic!(f64);
-impl_basic!(String);
-impl_basic!(std::net::IpAddr);
-impl_basic!(std::net::Ipv4Addr);
-impl_basic!(std::net::Ipv6Addr);
-impl_basic!(std::time::Duration);
-impl_basic!(std::time::SystemTime);
-impl_basic!(bytes::Bytes);
-// This is somewhat unfortunate. We should separate this module out into
-// its own crate, and just derive(Named) in `ndslice`. As it is, this would
-// create a circular (and heavy!) dependency for `ndslice`.
-impl_basic!(ndslice::Point);
-
-impl Named for &'static str {
-    fn typename() -> &'static str {
-        "&str"
-    }
-}
-
-// A macro that implements type-keyed interning of typenames. This is useful
-// for implementing [`Named`] for generic types.
-#[doc(hidden)] // not part of the public API
-#[macro_export]
-macro_rules! intern_typename {
-    ($key:ty, $format_string:expr, $($args:ty),+) => {
-        {
-            static CACHE: std::sync::LazyLock<$crate::dashmap::DashMap<std::any::TypeId, &'static str>> =
-              std::sync::LazyLock::new($crate::dashmap::DashMap::new);
-
-            match CACHE.entry(std::any::TypeId::of::<$key>()) {
-                $crate::dashmap::mapref::entry::Entry::Vacant(entry) => {
-                    let typename = format!($format_string, $(<$args>::typename()),+).leak();
-                    entry.insert(typename);
-                    typename
-                }
-                $crate::dashmap::mapref::entry::Entry::Occupied(entry) => *entry.get(),
-            }
-        }
-    };
-}
-pub use intern_typename;
-
-macro_rules! tuple_format_string {
-    ($a:ident,) => { "{}" };
-    ($a:ident, $($rest_a:ident,)+) => { concat!("{}, ", tuple_format_string!($($rest_a,)+)) };
-}
-
-macro_rules! impl_tuple_peel {
-    ($name:ident, $($other:ident,)*) => (impl_tuple! { $($other,)* })
-}
-
-macro_rules! impl_tuple {
-    () => ();
-    ( $($name:ident,)+ ) => (
-        impl<$($name:Named + 'static),+> Named for ($($name,)+) {
-            fn typename() -> &'static str {
-                intern_typename!(Self, concat!("(", tuple_format_string!($($name,)+), ")"), $($name),+)
-            }
-        }
-        impl_tuple_peel! { $($name,)+ }
-    )
-}
-
-impl_tuple! { E, D, C, B, A, Z, Y, X, W, V, U, T, }
-
-impl<T: Named + 'static> Named for Option<T> {
-    fn typename() -> &'static str {
-        intern_typename!(Self, "Option<{}>", T)
-    }
-}
-
-impl<T: Named + 'static> Named for Vec<T> {
-    fn typename() -> &'static str {
-        intern_typename!(Self, "Vec<{}>", T)
-    }
-}
-
-impl<K: Named + 'static, V: Named + 'static> Named for HashMap<K, V> {
-    fn typename() -> &'static str {
-        intern_typename!(Self, "HashMap<{}, {}>", K, V)
-    }
-}
-
-impl<T: Named + 'static, E: Named + 'static> Named for Result<T, E> {
-    fn typename() -> &'static str {
-        intern_typename!(Self, "Result<{}, {}>", T, E)
-    }
-}
-
-impl<T: Named + 'static> Named for std::ops::Range<T> {
-    fn typename() -> &'static str {
-        intern_typename!(Self, "std::ops::Range<{}>", T)
-    }
-}
-
-static SHAPE_CACHED_TYPEHASH: LazyLock<u64> =
-    LazyLock::new(|| cityhasher::hash(<ndslice::shape::Shape as Named>::typename()));
-
-impl Named for ndslice::shape::Shape {
-    fn typename() -> &'static str {
-        "ndslice::shape::Shape"
-    }
-
-    fn typehash() -> u64 {
-        *SHAPE_CACHED_TYPEHASH
-    }
-}
-
-/// Really internal, but needs to be exposed for macro.
 #[doc(hidden)]
 #[derive(Debug)]
 pub struct TypeInfo {

hyperactor_named/Cargo.toml

@@ -0,0 +1,19 @@
+# @generated by autocargo from //monarch/hyperactor_named:hyperactor_named
+
+[package]
+name = "hyperactor_named"
+version = "0.0.0"
+authors = ["Facebook <opensource+crates-hyperactor@fb.com>"]
+edition = "2021"
+description = "Core Named trait for Hyperactor types with globally unique names"
+repository = "https://github.com/meta-pytorch/monarch/"
+license = "BSD-3-Clause"
+
+[lib]
+edition = "2024"
+
+[dependencies]
+bytes = { version = "1.10", features = ["serde"] }
+cityhasher = "0.1.0"
+dashmap = { version = "5.5.3", features = ["rayon", "serde"] }
+ndslice = { version = "0.0.0", path = "../ndslice" }