chore: move memfd detect to detect crate (#213)

Signed-off-by: usamoi <[email protected]>

Author: usamoi

Cargo.lock

@@ -28,6 +28,7 @@ bincode.workspace = true
 half.workspace = true
 num-traits.workspace = true
 service = { path = "crates/service" }
+detect = { path = "crates/detect" }
 pgrx = { git = "https://github.com/tensorchord/pgrx.git", rev = "7c30e2023876c1efce613756f5ec81f3ab05696b", default-features = false, features = [
 ] }
 openai_api_rust = { git = "https://github.com/tensorchord/openai-api.git", rev = "228d54b6002e98257b3c81501a054942342f585f" }
@@ -70,7 +71,7 @@ half = { version = "~2.3", features = [
 ] }
 num-traits = "~0.2"
 validator = { version = "~0.16", features = ["derive"] }
-rustix = { version = "~0.38", features = ["net", "mm"] }
+rustix = { version = "~0.38", features = ["fs", "net", "mm"] }
 
 [profile.dev]
 panic = "unwind"

Cargo.toml

@@ -6,3 +6,4 @@ edition.workspace = true
 [dependencies]
 std_detect = { git = "https://github.com/tensorchord/stdarch.git", branch = "avx512fp16" }
 ctor = "0.2.6"
+rustix.workspace = true

crates/detect/Cargo.toml

@@ -1 +1,2 @@
+pub mod linux;
 pub mod x86_64;

crates/detect/src/lib.rs

@@ -0,0 +1,24 @@
+#![cfg(target_os = "linux")]
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static ATOMIC_MEMFD: AtomicBool = AtomicBool::new(false);
+
+pub fn test_memfd() -> bool {
+    use rustix::fs::MemfdFlags;
+    use std::io::ErrorKind;
+    match rustix::fs::memfd_create(".memfd.VECTORS.SUPPORT", MemfdFlags::empty()) {
+        Ok(_) => true,
+        Err(e) if e.kind() == ErrorKind::Unsupported => false,
+        Err(_) => false,
+    }
+}
+
+#[ctor::ctor]
+fn ctor_memfd() {
+    ATOMIC_MEMFD.store(test_memfd(), Ordering::Relaxed);
+}
+
+pub fn detect_memfd() -> bool {
+    ATOMIC_MEMFD.load(Ordering::Relaxed)
+}

crates/detect/src/linux.rs

@@ -80,6 +80,6 @@ fn ctor_v2() {
     ATOMIC_V2.store(test_v2(), Ordering::Relaxed);
 }
 
-pub fn _detect_v2() -> bool {
+pub fn detect_v2() -> bool {
     ATOMIC_V2.load(Ordering::Relaxed)
 }

crates/detect/src/x86_64.rs

@@ -0,0 +1,6 @@
+#![cfg(target_os = "linux")]
+
+#[test]
+fn print() {
+    assert_eq!(detect::linux::test_memfd(), detect::linux::detect_memfd());
+}

crates/detect/tests/linux.rs

@@ -0,0 +1,12 @@
+#![cfg(target_arch = "x86_64")]
+
+#[test]
+fn print() {
+    assert_eq!(
+        detect::x86_64::test_avx512fp16(),
+        detect::x86_64::detect_avx512fp16()
+    );
+    assert_eq!(detect::x86_64::test_v4(), detect::x86_64::detect_v4());
+    assert_eq!(detect::x86_64::test_v3(), detect::x86_64::detect_v3());
+    assert_eq!(detect::x86_64::test_v2(), detect::x86_64::detect_v2());
+}

crates/detect/tests/x86_64.rs

@@ -50,13 +50,16 @@ impl Rpc {
     pub fn new(socket: ClientSocket) -> Self {
         Self { socket }
     }
-    pub fn create(self: &mut ClientGuard<Self>, id: Id, options: IndexOptions) {
+}
+
+impl ClientGuard<Rpc> {
+    pub fn create(&mut self, id: Id, options: IndexOptions) {
         let packet = RpcPacket::Create { id, options };
         self.socket.send(packet).friendly();
         let create::CreatePacket::Leave {} = self.socket.recv().friendly();
     }
     pub fn search(
-        self: &mut ClientGuard<Self>,
+        &mut self,
         id: Id,
         search: (DynamicVector, usize),
         prefilter: bool,
@@ -81,7 +84,7 @@ impl Rpc {
             }
         }
     }
-    pub fn delete(self: &mut ClientGuard<Self>, id: Id, mut t: impl Delete) {
+    pub fn delete(&mut self, id: Id, mut t: impl Delete) {
         let packet = RpcPacket::Delete { id };
         self.socket.send(packet).friendly();
         loop {
@@ -97,32 +100,28 @@ impl Rpc {
             }
         }
     }
-    pub fn insert(self: &mut ClientGuard<Self>, id: Id, insert: (DynamicVector, Pointer)) {
+    pub fn insert(&mut self, id: Id, insert: (DynamicVector, Pointer)) {
         let packet = RpcPacket::Insert { id, insert };
         self.socket.send(packet).friendly();
         let insert::InsertPacket::Leave {} = self.socket.recv().friendly();
     }
-    pub fn flush(self: &mut ClientGuard<Self>, id: Id) {
+    pub fn flush(&mut self, id: Id) {
         let packet = RpcPacket::Flush { id };
         self.socket.send(packet).friendly();
         let flush::FlushPacket::Leave {} = self.socket.recv().friendly();
     }
-    pub fn destory(self: &mut ClientGuard<Self>, ids: Vec<Id>) {
+    pub fn destory(&mut self, ids: Vec<Id>) {
         let packet = RpcPacket::Destory { ids };
         self.socket.send(packet).friendly();
         let destory::DestoryPacket::Leave {} = self.socket.recv().friendly();
     }
-    pub fn stat(self: &mut ClientGuard<Self>, id: Id) -> IndexStat {
+    pub fn stat(&mut self, id: Id) -> IndexStat {
         let packet = RpcPacket::Stat { id };
         self.socket.send(packet).friendly();
         let stat::StatPacket::Leave { result } = self.socket.recv().friendly();
         result
     }
-    pub fn vbase(
-        mut self: ClientGuard<Self>,
-        id: Id,
-        vbase: (DynamicVector, usize),
-    ) -> ClientGuard<Vbase> {
+    pub fn vbase(mut self, id: Id, vbase: (DynamicVector, usize)) -> ClientGuard<Vbase> {
         let packet = RpcPacket::Vbase { id, vbase };
         self.socket.send(packet).friendly();
         let vbase::VbaseErrorPacket {} = self.socket.recv().friendly();
@@ -155,13 +154,16 @@ pub struct Vbase {
 }
 
 impl Vbase {
-    pub fn next(self: &mut ClientGuard<Self>) -> Option<Pointer> {
+    pub fn next(&mut self) -> Option<Pointer> {
         let packet = vbase::VbasePacket::Next {};
         self.socket.send(packet).friendly();
         let vbase::VbaseNextPacket { p } = self.socket.recv().friendly();
         p
     }
-    pub fn leave(mut self: ClientGuard<Self>) -> ClientGuard<Rpc> {
+}
+
+impl ClientGuard<Vbase> {
+    pub fn leave(mut self) -> ClientGuard<Rpc> {
         let packet = vbase::VbasePacket::Leave {};
         self.socket.send(packet).friendly();
         let vbase::VbaseLeavePacket {} = self.socket.recv().friendly();

src/ipc/client/mod.rs

@@ -2,8 +2,6 @@
 //!
 //! Provides an easy-to-use extension for vector similarity search.
 #![feature(offset_of)]
-#![feature(arbitrary_self_types)]
-#![feature(lazy_cell)]
 #![feature(never_type)]
 
 mod bgworker;

src/lib.rs

@@ -2,17 +2,6 @@ use rustix::fd::{AsFd, OwnedFd};
 use rustix::mm::{MapFlags, ProtFlags};
 use std::sync::atomic::AtomicU32;
 
-#[cfg(target_os = "linux")]
-static SUPPORT_MEMFD: std::sync::LazyLock<bool> = std::sync::LazyLock::new(|| {
-    use rustix::fs::MemfdFlags;
-    use std::io::ErrorKind;
-    match rustix::fs::memfd_create(".memfd.VECTORS.SUPPORT", MemfdFlags::empty()) {
-        Ok(_) => true,
-        Err(e) if e.kind() == ErrorKind::Unsupported => false,
-        Err(_) => false,
-    }
-});
-
 #[cfg(target_os = "linux")]
 pub unsafe fn futex_wait(futex: &AtomicU32, value: u32) {
     const FUTEX_TIMEOUT: libc::timespec = libc::timespec {
@@ -39,7 +28,7 @@ pub unsafe fn futex_wake(futex: &AtomicU32) {
 
 #[cfg(target_os = "linux")]
 pub fn memfd_create() -> std::io::Result<OwnedFd> {
-    if *SUPPORT_MEMFD {
+    if detect::linux::detect_memfd() {
         use rustix::fs::MemfdFlags;
         Ok(rustix::fs::memfd_create(
             format!(".memfd.VECTORS.{:x}", std::process::id()),