wtx 0.43.1

A collection of different transport implementations and related tools focused primarily on web technologies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use crate::sync::{AtomicUsize, Backoff, fence};
use core::{mem, sync::atomic::Ordering};

/// Sequential lock
#[derive(Debug)]
pub(crate) struct SeqLock {
  state: AtomicUsize,
}

impl SeqLock {
  #[inline]
  pub(crate) const fn new() -> Self {
    Self { state: AtomicUsize::new(0) }
  }

  #[inline]
  pub(crate) fn optimistic_read(&self) -> Option<usize> {
    let state = self.state.load(Ordering::Acquire);
    if state == 1 { None } else { Some(state) }
  }

  #[inline]
  pub(crate) fn validate_read(&self, stamp: usize) -> bool {
    fence(Ordering::Acquire);
    self.state.load(Ordering::Relaxed) == stamp
  }

  #[inline]
  pub(crate) fn write(&'static self) -> SeqLockWriteGuard {
    let backoff = Backoff::new();
    loop {
      let previous = self.state.swap(1, Ordering::Acquire);
      if previous != 1 {
        fence(Ordering::Release);
        return SeqLockWriteGuard { lock: self, state: previous };
      }
      backoff.snooze();
    }
  }
}

pub(crate) struct SeqLockWriteGuard {
  lock: &'static SeqLock,
  state: usize,
}

impl SeqLockWriteGuard {
  pub(crate) fn abort(self) {
    self.lock.state.store(self.state, Ordering::Release);
    #[expect(clippy::mem_forget, reason = "avoids incrementing the stamp")]
    mem::forget(self);
  }
}

impl Drop for SeqLockWriteGuard {
  fn drop(&mut self) {
    self.lock.state.store(self.state.wrapping_add(2), Ordering::Release);
  }
}