add comments

Author: Lslightly

src/lock/clhlock.rs

@@ -23,7 +23,7 @@ pub struct ClhLock {
 
 impl Node {
     fn new(locked: bool) -> *mut CachePadded<Self> {
-        Box::into_raw(Box::new(CachePadded::new(Self {
+        Box::into_raw(Box::new(CachePadded::new(Self { // Box allocated in heap
             locked: AtomicBool::new(locked),
         })))
     }

src/lock/mcslock.rs

@@ -74,14 +74,15 @@ unsafe impl RawLock for McsLock {
             if self
                 .tail
                 .compare_exchange(node, ptr::null_mut(), Release, Relaxed)
-                .is_ok()
+                .is_ok() // no other thread is waiting, set tail to null
             {
                 // SAFETY: Since `node` was the `tail`, there is no other thread blocked by this
                 // lock. Hence we have unique access to it.
                 drop(unsafe { Box::from_raw(node) });
                 return;
             }
 
+            // another thread succeed in swap tail but not set prev yet
             while {
                 next = unsafe { (*node).next.load(Acquire) };
                 next.is_null()

src/lock/mcsparkinglock.rs

@@ -92,6 +92,7 @@ unsafe impl RawLock for McsParkingLock {
 
         // It is important to clone the thread before unlocking, the next waiter,
         // because then the next waiter may free `next_ref`.
+        // If not, use after free may occur if next_ref quickly unlock.
         let thread = next_ref.thread.clone();
         next_ref.locked.store(false, Release);
         thread.unpark();

src/lock/ticketlock.rs

@@ -25,7 +25,7 @@ unsafe impl RawLock for TicketLock {
     type Token = usize;
 
     fn lock(&self) -> usize {
-        let ticket = self.next.fetch_add(1, Relaxed);
+        let ticket = self.next.fetch_add(1, Relaxed); // fetch_add is fair => TicketLock is fair. fetch_add is not fair => TicketLock is not fair
         let backoff = Backoff::new();
 
         while self.curr.load(Acquire) != ticket {