global: snapshot

crates/brk_vec/src/structs/mod.rs

@@ -0,0 +1,5 @@
+mod unsafe_slice;
+mod version;
+
+pub use unsafe_slice::*;
+pub use version::*;

crates/brk_vec/src/structs/unsafe_slice.rs

@@ -0,0 +1,30 @@
+use std::cell::UnsafeCell;
+
+#[derive(Copy, Clone)]
+pub struct UnsafeSlice<'a, T>(&'a [UnsafeCell<T>]);
+unsafe impl<T: Send + Sync> Send for UnsafeSlice<'_, T> {}
+unsafe impl<T: Send + Sync> Sync for UnsafeSlice<'_, T> {}
+
+impl<'a, T> UnsafeSlice<'a, T> {
+    pub fn new(slice: &'a mut [T]) -> Self {
+        let ptr = slice as *mut [T] as *const [UnsafeCell<T>];
+        Self(unsafe { &*ptr })
+    }
+
+    /// SAFETY: It is UB if two threads write to the same index without
+    /// synchronization.
+    pub fn write(&self, i: usize, value: T) {
+        unsafe {
+            *self.0[i].get() = value;
+        }
+    }
+
+    pub fn copy_slice(&self, start: usize, slice: &[T])
+    where
+        T: Copy,
+    {
+        slice.iter().enumerate().for_each(|(i, v)| {
+            self.write(start + i, *v);
+        });
+    }
+}

crates/brk_vec/src/structs/version.rs

@@ -0,0 +1,37 @@
+use std::{
+    fs,
+    io::{self, Read},
+    path::Path,
+};
+
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
+
+use crate::Error;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, FromBytes, IntoBytes, Immutable, KnownLayout)]
+pub struct Version(u32);
+
+impl Version {
+    pub fn write(&self, path: &Path) -> Result<(), io::Error> {
+        fs::write(path, self.as_bytes())
+    }
+
+    pub fn swap_bytes(self) -> Self {
+        Self(self.0.swap_bytes())
+    }
+}
+
+impl From<u32> for Version {
+    fn from(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl TryFrom<&Path> for Version {
+    type Error = Error;
+    fn try_from(value: &Path) -> Result<Self, Self::Error> {
+        let mut buf = [0; 4];
+        fs::read(value)?.as_slice().read_exact(&mut buf)?;
+        Ok(*(Self::ref_from_bytes(&buf)?))
+    }
+}