From a04cf2dbb8d2e890405fbf0a1022aaad3015b1e8 Mon Sep 17 00:00:00 2001 From: Christian Cunningham Date: Fri, 26 Aug 2022 17:25:34 -0700 Subject: Modularize --- src/util/fifo_queue.rs | 191 ------------------------------------------------- 1 file changed, 191 deletions(-) delete mode 100644 src/util/fifo_queue.rs (limited to 'src/util/fifo_queue.rs') diff --git a/src/util/fifo_queue.rs b/src/util/fifo_queue.rs deleted file mode 100644 index 6748ab4..0000000 --- a/src/util/fifo_queue.rs +++ /dev/null @@ -1,191 +0,0 @@ -//! # FIFO Queue -//! -//! Provides the FIFO queue structure for allocations -use crate::sync::interface::Mutex; -use crate::sync::NullLock; -use crate::serial_vprintln; -use core::fmt; -use core::fmt::{Debug, Formatter}; - -/// # Initialize Queue -/// - Name: Symbol name -/// - Size: Number of elements -/// - Default: Default value -/// - Type: Data Type -#[macro_export] -macro_rules! init_queue { - ($name:tt,$size:tt,$default:tt,$type:ty) => { - init_queue!{@gen [$name,$size,$default,$type,concat!("# ", stringify!($type), " Queue Allocator")]} - }; - (@gen [$name:tt,$size:tt,$default:tt,$type:ty,$doc:expr]) => { - #[doc = $doc] - #[link_section = ".data.alloc"] - pub static $name: QueueAllocator<'static, $type, {$size+2}> = QueueAllocator::<$type, {$size+2}>{inner: NullLock::new([QueueItem::new($default); {$size+2}])}; - }; -} - -#[derive(Copy, Clone)] -/// # Queue Item -/// -/// Encapsulates a data element and a pointer to -/// the next `Queue` item -pub struct QueueItem<'a, T: Sized> { - /// # Data - /// - /// The encapsulated data - data: T, - /// # Pointer to the next item - /// - /// Stores either `None` or points - /// to the next item. - next: Option<*mut QueueItem<'a, T>>, -} - -impl QueueItem<'_, T> { - /// # Constructor - pub const fn new(data: T) -> Self { - Self { - data: data, - next: None, - } - } - /// # Get the inner data - /// - /// Returns a borrow of the underlying data. - pub fn inner(&mut self) -> &mut T { - &mut self.data - } - /// # Get pointer to inner data - pub fn ptr(&mut self) -> *mut u8 { - self.inner() as *mut T as *mut u8 - } -} - -/// # Sharing Thread Safety for QueueItem -unsafe impl Send for QueueItem<'_, T> {} - -impl Debug for QueueItem<'_, T> { - /// # Debug formatter for `QueueItem` - /// - /// Output the encapsulated data - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - #[cfg(feature = "verbose")] - return write!( - f, - "{:?} {:x} {:?}", - self.data, self as *const QueueItem<'_, T> as usize, self.next - ); - - #[cfg(not(feature = "verbose"))] - return write!(f, "{:?}", self.data); - } -} - -/// # Queue Allocator -/// -/// Structure to store a pool of allocated data structures. -pub struct QueueAllocator<'a, T: Sized, const COUNT: usize> { - /// # Synchronized Pool of items - /// - /// Stores synchronization wrapper around the data pool - pub inner: NullLock<[QueueItem<'a, T>; COUNT]>, -} - -/// # Sharing Thread Safety for QueueAllocator -unsafe impl Send for QueueAllocator<'_, T, COUNT> {} - -impl<'a, T: Sized, const COUNT: usize> QueueAllocator<'a, T, COUNT> { - /// # Initialization of Fixed-Size Pool - /// - /// Establishes the header and footer of the queue - /// as the first and second elements respectively. - /// All of the internal elements point to the next - /// one and the final element points to `None` - pub fn init(&self) { - serial_vprintln!("QA: Initializing Queue Allocator!"); - self.inner.lock(|queue| { - serial_vprintln!("QA: Clearing internal references..."); - for idx in 2..COUNT { - if idx != COUNT - 1 { - queue[idx].next = Some(&mut queue[idx + 1] as *mut QueueItem<'a, T>); - } else { - queue[idx].next = None; - } - } - serial_vprintln!("QA: Initializing head and tail..."); - queue[0].next = Some(&mut queue[2] as *mut QueueItem<'a, T>); - queue[1].next = Some(&mut queue[COUNT - 1] as *mut QueueItem<'a, T>); - }); - serial_vprintln!("QA: Initialized Queue Allocator!"); - } - - /// # Allocate Data - /// - /// If there is a data chunk available, - /// return it, otherwise return `None` - #[allow(dead_code)] - pub fn alloc(&self) -> Option<&mut QueueItem<'a, T>> { - serial_vprintln!("QA: Allocating chunk!"); - return self.inner.lock(|pool| { - if let Some(entry) = pool[0].next { - serial_vprintln!("QA: Found chunk!"); - pool[0].next = unsafe { (*entry).next }; - unsafe { - (*entry).next = None; - } - match pool[0].next { - None => pool[1].next = None, - _ => {} - } - serial_vprintln!("QA: \x1b[92mAllocated {:x}\x1b[0m", unsafe { - (*entry).ptr() as usize - }); - return Some(unsafe { &mut *entry as &mut QueueItem<'a, T> }); - } else { - serial_vprintln!("QA: No chunks available!"); - return None; - } - }); - } - - /// # Free - /// - /// Add the item to the end of the queue. - /// If there were no items, set it as the head. - #[allow(dead_code)] - pub fn free(&self, freed_item: &mut QueueItem<'a, T>) { - serial_vprintln!("QA: Deallocating chunk!"); - self.inner.lock(|pool| { - freed_item.next = None; - match pool[1].next { - None => { - pool[0].next = Some(freed_item as *mut QueueItem<'a, T>); - } - Some(entry) => unsafe { - (*entry).next = Some(freed_item as *mut QueueItem<'a, T>); - }, - } - pool[1].next = Some(freed_item as *mut QueueItem<'a, T>); - serial_vprintln!( - "QA: \x1b[91mDeallocated {:x}\x1b[0m", - freed_item.ptr() as usize - ); - }); - } -} - -impl Debug for QueueAllocator<'_, T, COUNT> { - /// # Debug Formatted Output - /// - /// Output each data point in the array with - /// its debug formatter. - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - self.inner.lock(|queue| { - #[cfg(feature = "verbose")] - return write!(f, "{:?}", queue); - - #[cfg(not(feature = "verbose"))] - return write!(f, "{:?}", queue); - }) - } -} -- cgit v1.2.1