feat(utils): add the vendored rlsf to crate::utils::alloc

Author: yvt

src/r3_core/src/utils/alloc/mod.rs

@@ -2,3 +2,4 @@
 #[macro_use]
 mod vec;
 pub use vec::*;
+mod rlsf;

src/r3_core/src/utils/alloc/rlsf/flex/tests.rs

@@ -1,11 +1,11 @@
 use quickcheck_macros::quickcheck;
 use std::{fmt, prelude::v1::*};
 
-use super::*;
-use crate::{
+use super::super::{
     tests::ShadowAllocator,
-    utils::{nonnull_slice_end, nonnull_slice_len},
+    utils::{self, nonnull_slice_end, nonnull_slice_len},
 };
+use super::*;
 
 trait TestFlexSource: FlexSource {
     type Options: quickcheck::Arbitrary;
@@ -293,7 +293,7 @@ macro_rules! gen_test {
                                 sa!().allocate(layout, ptr);
 
                                 // Fill it with dummy data
-                                fill_data(crate::utils::nonnull_slice_from_raw_parts(ptr, len));
+                                fill_data(utils::nonnull_slice_from_raw_parts(ptr, len));
                             }
                         }
                         3..=5 => {
@@ -303,7 +303,7 @@ macro_rules! gen_test {
                                 log::trace!("dealloc {:?}", alloc);
 
                                 // Make sure the stored dummy data is not corrupted
-                                verify_data(crate::utils::nonnull_slice_from_raw_parts(alloc.ptr, alloc.layout.size()));
+                                verify_data(utils::nonnull_slice_from_raw_parts(alloc.ptr, alloc.layout.size()));
 
                                 unsafe { tlsf.deallocate(alloc.ptr, alloc.layout.align()) };
                                 sa!().deallocate(alloc.layout, alloc.ptr);
@@ -330,8 +330,8 @@ macro_rules! gen_test {
                                     log::trace!(" {:?} → {:?}", alloc.ptr, ptr);
 
                                     // Check and refill the dummy data
-                                    verify_data(crate::utils::nonnull_slice_from_raw_parts(ptr, len.min(alloc.layout.size())));
-                                    fill_data(crate::utils::nonnull_slice_from_raw_parts(ptr, len));
+                                    verify_data(utils::nonnull_slice_from_raw_parts(ptr, len.min(alloc.layout.size())));
+                                    fill_data(utils::nonnull_slice_from_raw_parts(ptr, len));
 
                                     sa!().deallocate(alloc.layout, alloc.ptr);
                                     alloc.ptr = ptr;

src/r3_core/src/utils/alloc/rlsf/mod.rs

@@ -0,0 +1,30 @@
+//! [`rlsf`][] modified for compile-time allocation.
+//!
+//! [`rlsf`]: https://crates.io/crates/rlsf
+// FIXME: `rlsf` targets a pre-`unsafe_op_in_unsafe_fn` stable compiler, so
+// it doesn't have `deny(unsafe_op_in_unsafe_fn)`. Eventually we need to remove
+// this because this lint "may become [...] hard error in a future edition" [1].
+//
+// [1]: https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1520-2021-05-06
+#![allow(unsafe_op_in_unsafe_fn)]
+#![allow(dead_code)]
+
+macro_rules! const_panic {
+    ($($tt:tt)*) => {
+        panic!($($tt)*)
+    };
+}
+
+use crate::utils::Init;
+
+mod flex;
+pub mod int;
+mod tlsf;
+mod utils;
+pub use self::{
+    flex::*,
+    tlsf::{Tlsf, GRANULARITY},
+};
+
+#[cfg(test)]
+mod tests;

src/r3_core/src/utils/alloc/rlsf/tlsf.rs

@@ -9,12 +9,12 @@ use core::{
     ptr::{addr_of, NonNull},
 };
 
-use crate::{
+use super::{
     int::BinInteger,
     utils::{nonnull_slice_from_raw_parts, nonnull_slice_len, nonnull_slice_start},
 };
 
-#[cfg_attr(doc, svgbobdoc::transform)]
+#[doc = svgbobdoc::transform!(
 /// The TLSF header (top-level) data structure.
 ///
 /// # Data Structure Overview
@@ -63,6 +63,7 @@ use crate::{
 ///
 /// The maximum block size is `(GRANULARITY << FLLEN) - GRANULARITY`.
 ///
+)]
 #[derive(Debug)]
 pub struct Tlsf<'pool, FLBitmap, SLBitmap, const FLLEN: usize, const SLLEN: usize> {
     fl_bitmap: FLBitmap,
@@ -433,7 +434,7 @@ impl<'pool, FLBitmap: BinInteger, SLBitmap: BinInteger, const FLLEN: usize, cons
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust,ignore
     /// use rlsf::Tlsf;
     /// use std::{mem::MaybeUninit, ptr::NonNull};
     /// static mut POOL: MaybeUninit<[u8; 1024]> = MaybeUninit::uninit();
@@ -555,7 +556,7 @@ impl<'pool, FLBitmap: BinInteger, SLBitmap: BinInteger, const FLLEN: usize, cons
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust,ignore
     /// use rlsf::Tlsf;
     /// use std::{mem::MaybeUninit, ptr::NonNull};
     ///
@@ -699,7 +700,7 @@ impl<'pool, FLBitmap: BinInteger, SLBitmap: BinInteger, const FLLEN: usize, cons
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust,ignore
     /// use rlsf::Tlsf;
     /// use std::mem::MaybeUninit;
     /// let mut pool = [MaybeUninit::uninit(); 1024];
@@ -709,7 +710,7 @@ impl<'pool, FLBitmap: BinInteger, SLBitmap: BinInteger, const FLLEN: usize, cons
     ///
     /// The insertred memory block must outlive `self`:
     ///
-    /// ```rust,compile_fail
+    /// ```rust,ignore
     /// use rlsf::Tlsf;
     /// use std::mem::MaybeUninit;
     /// let mut tlsf: Tlsf<u8, u8, 8, 8> = Tlsf::INIT;

src/r3_core/src/utils/alloc/rlsf/tlsf/tests.rs

@@ -1,8 +1,8 @@
 use quickcheck_macros::quickcheck;
 use std::{mem::MaybeUninit, prelude::v1::*};
 
+use super::super::{tests::ShadowAllocator, utils::nonnull_slice_from_raw_parts};
 use super::*;
-use crate::{tests::ShadowAllocator, utils::nonnull_slice_from_raw_parts};
 
 #[repr(align(64))]
 struct Align<T>(T);
@@ -179,6 +179,8 @@ macro_rules! gen_test {
                 let mut sa = ShadowAllocator::new();
                 let mut tlsf: TheTlsf = Tlsf::INIT;
 
+                let pool_size = pool_size % 0x1000000;
+
                 let mut pool = Align([MaybeUninit::<u8>::uninit(); 65536]);
                 let pool_ptr;
                 // The end index of the memory pool inserted to `tlsf`