autocommit 2022-02-11 02:28:11 CET

src/utils/asyncevent.rs

@@ -11,6 +11,10 @@ pub struct AsyncEvent {
 }
 
 impl AsyncEvent {
+    pub fn clear(&self) {
+        self.waker.take();
+    }
+
     pub fn trigger(&self) {
         self.triggers.fetch_add(1);
         if let Some(waker) = self.waker.take() {

src/utils/buffd/buf_out.rs

@@ -65,9 +65,7 @@ impl OutBufferSwapchain {
 
     pub fn commit(&mut self) {
         if self.cur.write_pos > 0 {
-            let new = self.free.pop().unwrap_or_else(|| {
-                Default::default()
-            });
+            let new = self.free.pop().unwrap_or_else(|| Default::default());
             let old = mem::replace(&mut self.cur, new);
             self.pending.push_back(old);
         }

src/utils/clonecell.rs

@@ -1,6 +1,7 @@
 use crate::utils::linkedlist::NodeRef;
 use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
 use std::cell::UnsafeCell;
+use std::fmt::{Debug, Formatter};
 use std::mem;
 use std::rc::Rc;
 
@@ -8,6 +9,12 @@ pub struct CloneCell<T: UnsafeCellCloneSafe> {
     data: UnsafeCell<T>,
 }
 
+impl<T: UnsafeCellCloneSafe + Debug> Debug for CloneCell<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        unsafe { self.data.get().deref().fmt(f) }
+    }
+}
+
 impl<T: UnsafeCellCloneSafe> CloneCell<T> {
     pub fn new(t: T) -> Self {
         Self {

src/utils/linkedlist.rs

@@ -1,7 +1,7 @@
 use crate::utils::ptr_ext::PtrExt;
 use crate::NumCell;
 use std::cell::Cell;
-use std::mem::MaybeUninit;
+use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
 use std::ptr::NonNull;
 
@@ -9,6 +9,12 @@ pub struct LinkedList<T> {
     root: LinkedNode<T>,
 }
 
+impl<T: Debug> Debug for LinkedList<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
 impl<T> Default for LinkedList<T> {
     fn default() -> Self {
         Self::new()
@@ -18,10 +24,10 @@ impl<T> Default for LinkedList<T> {
 impl<T> LinkedList<T> {
     pub fn new() -> Self {
         let node = Box::into_raw(Box::new(NodeData {
-            rc: NumCell::new(3),
+            rc: NumCell::new(1),
             prev: Cell::new(NonNull::dangling()),
             next: Cell::new(NonNull::dangling()),
-            data: MaybeUninit::uninit(),
+            data: None,
         }));
         unsafe {
             node.deref().prev.set(NonNull::new_unchecked(node));
@@ -151,11 +157,17 @@ pub struct LinkedNode<T> {
     data: NonNull<NodeData<T>>,
 }
 
+impl<T: Debug> Debug for LinkedNode<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        unsafe { self.data.as_ref().data.as_ref().unwrap_unchecked().fmt(f) }
+    }
+}
+
 impl<T> Deref for LinkedNode<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        unsafe { self.data.as_ref().data.assume_init_ref() }
+        unsafe { self.data.as_ref().data.as_ref().unwrap_unchecked() }
     }
 }
 
@@ -163,11 +175,17 @@ pub struct NodeRef<T> {
     data: NonNull<NodeData<T>>,
 }
 
+impl<T: Debug> Debug for NodeRef<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        unsafe { self.data.as_ref().data.as_ref().unwrap_unchecked().fmt(f) }
+    }
+}
+
 impl<T> Deref for NodeRef<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        unsafe { self.data.as_ref().data.assume_init_ref() }
+        unsafe { self.data.as_ref().data.as_ref().unwrap_unchecked() }
     }
 }
 
@@ -197,22 +215,16 @@ impl<T> NodeRef<T> {
         unsafe { append(self.data, t) }
     }
 
-    pub fn prev(&self) -> NodeRef<T> {
+    pub fn prev(&self) -> Option<NodeRef<T>> {
         unsafe {
             let data = self.data.as_ref();
             let other = data.prev.get();
-            other.as_ref().rc.fetch_add(1);
-            NodeRef { data: other }
-        }
-    }
-
-    #[allow(dead_code)]
-    pub fn next(&self) -> NodeRef<T> {
-        unsafe {
-            let data = self.data.as_ref();
-            let other = data.next.get();
-            other.as_ref().rc.fetch_add(1);
-            NodeRef { data: other }
+            if other.as_ref().data.is_some() {
+                other.as_ref().rc.fetch_add(1);
+                Some(NodeRef { data: other })
+            } else {
+                None
+            }
         }
     }
 }
@@ -221,7 +233,7 @@ struct NodeData<T> {
     rc: NumCell<usize>,
     prev: Cell<NonNull<NodeData<T>>>,
     next: Cell<NonNull<NodeData<T>>>,
-    data: MaybeUninit<T>,
+    data: Option<T>,
 }
 
 unsafe fn dec_ref_count<T>(slf: NonNull<NodeData<T>>, n: usize) {
@@ -237,8 +249,10 @@ impl<T> Drop for LinkedNode<T> {
                 let data = self.data.as_ref();
                 data.prev.get().as_ref().next.set(data.next.get());
                 data.next.get().as_ref().prev.set(data.prev.get());
+                data.prev.set(self.data);
+                data.next.set(self.data);
             }
-            dec_ref_count(self.data, 3);
+            dec_ref_count(self.data, 1);
         }
     }
 }
@@ -263,10 +277,10 @@ impl<T> LinkedNode<T> {
 unsafe fn prepend<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
     let dref = data.as_ref();
     let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
-        rc: NumCell::new(3),
+        rc: NumCell::new(1),
         prev: Cell::new(dref.prev.get()),
         next: Cell::new(data),
-        data: MaybeUninit::new(t),
+        data: Some(t),
     })));
     dref.prev.get().as_ref().next.set(node);
     dref.prev.set(node);
@@ -276,10 +290,10 @@ unsafe fn prepend<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
 unsafe fn append<T>(data: NonNull<NodeData<T>>, t: T) -> LinkedNode<T> {
     let dref = data.as_ref();
     let node = NonNull::new_unchecked(Box::into_raw(Box::new(NodeData {
-        rc: NumCell::new(3),
+        rc: NumCell::new(1),
         prev: Cell::new(data),
         next: Cell::new(dref.next.get()),
-        data: MaybeUninit::new(t),
+        data: Some(t),
     })));
     dref.next.get().as_ref().prev.set(node);
     dref.next.set(node);

src/utils/mod.rs

@@ -7,7 +7,6 @@ pub mod debug_fn;
 pub mod errorfmt;
 pub mod linkedlist;
 pub mod numcell;
-pub mod oneshot;
 pub mod ptr_ext;
 pub mod queue;
 pub mod smallmap;

src/utils/numcell.rs

@@ -1,4 +1,5 @@
 use std::cell::Cell;
+use std::fmt::{Debug, Formatter};
 use std::ops::{Add, BitAnd, BitOr, Sub};
 
 #[derive(Default)]
@@ -6,6 +7,12 @@ pub struct NumCell<T> {
     t: Cell<T>,
 }
 
+impl<T: Copy + Debug> Debug for NumCell<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.t.get().fmt(f)
+    }
+}
+
 impl<T> NumCell<T> {
     #[inline(always)]
     pub fn new(t: T) -> Self {

src/utils/oneshot.rs

@@ -1,48 +0,0 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll, Waker};
-
-pub fn oneshot<T>() -> (OneshotTx<T>, OneshotRx<T>) {
-    let os = Rc::new(Oneshot {
-        data: Cell::new(None),
-        waiter: Cell::new(None),
-    });
-    (OneshotTx { data: os.clone() }, OneshotRx { data: os })
-}
-
-struct Oneshot<T> {
-    data: Cell<Option<T>>,
-    waiter: Cell<Option<Waker>>,
-}
-
-pub struct OneshotTx<T> {
-    data: Rc<Oneshot<T>>,
-}
-
-pub struct OneshotRx<T> {
-    data: Rc<Oneshot<T>>,
-}
-
-impl<T> OneshotTx<T> {
-    pub fn send(self, t: T) {
-        self.data.data.set(Some(t));
-        if let Some(waiter) = self.data.waiter.replace(None) {
-            waiter.wake();
-        }
-    }
-}
-
-impl<T> Future for OneshotRx<T> {
-    type Output = T;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if let Some(data) = self.data.data.replace(None) {
-            Poll::Ready(data)
-        } else {
-            self.data.waiter.set(Some(cx.waker().clone()));
-            Poll::Pending
-        }
-    }
-}

src/utils/queue.rs

@@ -35,6 +35,7 @@ impl<T> AsyncQueue<T> {
 
     pub fn clear(&self) {
         mem::take(&mut *self.data.borrow_mut());
+        mem::take(&mut *self.waiters.borrow_mut());
     }
 }
 

src/utils/smallmap.rs

@@ -2,12 +2,23 @@ use crate::utils::clonecell::UnsafeCellCloneSafe;
 use crate::utils::ptr_ext::{MutPtrExt, PtrExt};
 use smallvec::SmallVec;
 use std::cell::UnsafeCell;
+use std::fmt::{Debug, Formatter};
 use std::mem;
 
 pub struct SmallMap<K, V, const N: usize> {
     m: UnsafeCell<SmallVec<[(K, V); N]>>,
 }
 
+impl<K: Debug, V: Debug, const N: usize> Debug for SmallMap<K, V, N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        unsafe {
+            f.debug_map()
+                .entries(self.m.get().deref().iter().map(|e| (&e.0, &e.1)))
+                .finish()
+        }
+    }
+}
+
 impl<K, V, const N: usize> Default for SmallMap<K, V, N> {
     fn default() -> Self {
         Self {