swym 0.1.0-preview

Transactional memory for rust
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

use crate::internal::pointer::PtrExt;
use std::{
    num::NonZeroUsize,
    ptr::NonNull,
    sync::atomic::{
        AtomicUsize,
        Ordering::{self, Acquire, Relaxed, Release},
    },
};

#[inline(always)]
unsafe fn store_nonoverlapping_impl(dest_ptr: NonNull<AtomicUsize>, src: &[usize], o: Ordering) {
    // non-overlapping
    let len = src.len();
    assume!(
        len > 0,
        "`seqlock_store_nonoverlapping_impl` does not work for zero sized types"
    );
    let len = NonZeroUsize::new_unchecked(len);

    {
        let src_ptr: NonNull<_> = src.get_unchecked(0).into();
        assume!(
            src_ptr.add(len.get()) <= dest_ptr.cast() || src_ptr >= dest_ptr.add(len.get()).cast(),
            "overlapping pointers passed in to `seqlock_store_nonoverlapping_impl`"
        );
    }

    for offset in 0..len.get() {
        dest_ptr
            .add(offset)
            .as_ref()
            .store(*src.get_unchecked(offset), o);
    }
}

#[inline(always)]
unsafe fn load_nonoverlapping_impl(src_ptr: NonNull<AtomicUsize>, dest: &mut [usize], o: Ordering) {
    // non-overlapping
    let len = dest.len();
    assume!(
        len > 0,
        "`seqlock_store_nonoverlapping_impl` does not work for zero sized types"
    );
    let len = NonZeroUsize::new_unchecked(len);

    {
        let dest_ptr: NonNull<_> = dest.get_unchecked(0).into();
        assume!(
            src_ptr.add(len.get()) <= dest_ptr.cast() || src_ptr >= dest_ptr.add(len.get()).cast(),
            "overlapping pointers passed in to `seqlock_store_nonoverlapping_impl`"
        );
    }

    for offset in 0..len.get() {
        *dest.get_unchecked_mut(offset) = src_ptr.add(offset).as_ref().load(o);
    }
}

#[inline]
pub unsafe fn store_nonoverlapping_release(dest_ptr: NonNull<AtomicUsize>, src: &[usize]) {
    store_nonoverlapping_impl(dest_ptr, src, Release);
}

#[inline]
pub unsafe fn load_nonoverlapping_acquire(src_ptr: NonNull<AtomicUsize>, dest: &mut [usize]) {
    load_nonoverlapping_impl(src_ptr, dest, Acquire);
}

#[inline]
pub unsafe fn load_nonoverlapping_relaxed(src_ptr: NonNull<AtomicUsize>, dest: &mut [usize]) {
    load_nonoverlapping_impl(src_ptr, dest, Relaxed);
}