tomt_async 0.1.3

Primarily a dumping ground for personal async snippets that may be used in other ToMT projects. If this crate is useful to others please let us know.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use std::{
    cell::UnsafeCell,
    sync::atomic::{AtomicUsize, Ordering},
    task::Poll,
};

#[derive(Debug)]
pub struct AsyncMut<T> {
    pub(in self) holder: AtomicUsize,
    next: AtomicUsize,
    pub(in self) data: UnsafeCell<T>,
}

unsafe impl<T: Send> Send
for AsyncMut<T> { }

unsafe impl<T> Sync
for AsyncMut<T> { }

impl<'me, T> AsyncMut<T>
{
    pub fn new(
        init: T
    ) -> Self {
        Self {
            holder: AtomicUsize::new(0),
            next: AtomicUsize::new(0),
            data: UnsafeCell::new(init),
        }
    }

    pub async fn lock(
        &'me self
    ) -> impl 'me + std::ops::Deref<Target = T> + std::ops::DerefMut + Drop {
        let my_token = {
            let mut tmp_token: usize = 0;
            std::future::poll_fn(move |_| {
                match self.next.compare_exchange(
                    tmp_token,
                    tmp_token + 1,
                    Ordering::Release,
                    Ordering::Relaxed
                ) {
                    Ok(mine) => Poll::Ready(mine),
                    Err(current) => {
                        tmp_token = current;
                        Poll::Pending
                    },
                }
            }).await
        };

        std::future::poll_fn(move |_| match self.holder.compare_exchange(
            my_token,
            my_token,
            Ordering::Release,
            Ordering::Relaxed,
        ) {
            Ok(my_token) => Poll::Ready(Lock::new(
                self,
                my_token
            )),
            Err(_held) => Poll::Pending,
        }).await
    }
}

struct Lock<'owner, T>
{
    owner: &'owner AsyncMut<T>,
    token: usize,
}

impl<'owner, T>
Lock<'owner, T>
{
    pub fn new(
        owner: &'owner AsyncMut<T>,
        token: usize
    ) -> Self {
        Self{ owner, token }
    }
}

impl<'owner, T> std::ops::Deref
for Lock<'owner, T>
{
    type Target = T;

    fn deref(
        &self
    ) -> &Self::Target {
        unsafe { & *self.owner.data.get() }
    }
}

impl<'owner, T> std::ops::DerefMut
for Lock<'owner, T>
{
    fn deref_mut(
        &mut self
    ) -> &mut Self::Target {
        unsafe { &mut *self.owner.data.get() }
    }
}

impl<'owner, T> Drop
for Lock<'owner, T>
{
    fn drop(
        &mut self
    ) {
        // spin lock drop

        while let Err(_other) = self.owner.holder.compare_exchange(
        self.token,
            self.token + 1, 
        Ordering::Release,
        Ordering::Relaxed
        ) {
            continue;
        }
    }
}