paradis 0.2.1

Parallel processing with disjoint indices
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

use crate::error::OutOfBounds;
use crate::index::{IndexList, UniqueIndexList};
use crate::{BoundedParAccess, Bounds, LinearParAccess, RecordIndex};
use paradis_core::ParAccess;
use std::any::type_name;

/// An access object that has been narrowed to a subset of its indices.
///
/// This is the result type for
/// [`narrow_access`](crate::index::narrow_access).
///
/// TODO: Provide method like `.ensure_in_bounds()` that ensures that
/// all bounds checks are statically eliminated (currently we rely on
/// compiler optimizations to eliminate those)
#[derive(Debug)]
pub struct NarrowedAccess<'a, Indices, Access> {
    indices: &'a Indices,
    access: Access,
    verified_in_bounds: bool,
}

impl<'a, Indices, Access> NarrowedAccess<'a, Indices, Access>
where
    Indices: IndexList,
    Indices::Index: RecordIndex,
    Access: BoundedParAccess<Indices::Index>,
{
    pub(crate) fn try_new(indices: &'a Indices, access: Access) -> Result<Self, OutOfBounds> {
        if let Some(index_bounds) = indices.bounds() {
            if access.bounds().contains_bounds(&index_bounds) {
                Ok(Self {
                    indices,
                    access,
                    verified_in_bounds: true,
                })
            } else {
                Err(OutOfBounds)
            }
        } else {
            assert!(
                !Indices::ALWAYS_BOUNDED,
                "IndexList {} claims that it is ALWAYS_BOUNDED, but no bounds were returned",
                type_name::<Indices>()
            );

            // In this case, bounds are not available, so we can not say
            // whether all indices in bounds. This means that we might panic
            // upon access instead
            Ok(Self {
                indices,
                access,
                verified_in_bounds: false,
            })
        }
    }
}

unsafe impl<'a, Indices, Access> ParAccess<usize> for NarrowedAccess<'a, Indices, Access>
where
    Indices: UniqueIndexList,
    Indices::Index: RecordIndex,
    Access: BoundedParAccess<Indices::Index>,
{
    type Record = Access::Record;

    #[inline(always)]
    unsafe fn clone_access(&self) -> Self {
        Self {
            indices: self.indices,
            access: unsafe { self.access.clone_access() },
            verified_in_bounds: self.verified_in_bounds,
        }
    }

    #[inline(always)]
    unsafe fn get_unsync_unchecked(&self, loc: usize) -> Self::Record {
        // SAFETY: Since this is an unchecked method, we can always directly try to obtain
        // the index at the requested location in the index list
        let index = unsafe { self.indices.get_index_unchecked(loc) };
        if Indices::ALWAYS_BOUNDED {
            // This branch hopefully allows us to completely eliminate all branches
            // whenever we're able to statically prove that bounds checking is unnecessary
            debug_assert!(self.verified_in_bounds);
            // SAFETY: This is sound due to the fact that
            // we've checked that all indices are in bounds when constructing Self
            unsafe { self.access.get_unsync_unchecked(index) }
        } else if self.verified_in_bounds {
            // SAFETY: This is sound due to the fact that
            // we've checked that all indices are in bounds when constructing Self
            unsafe { self.access.get_unsync_unchecked(index) }
        } else {
            // We cannot prove that all indices are in bounds, so we need
            // to use bounds checking to avoid possible unsoundness
            unsafe { self.access.get_unsync(index) }
        }
    }
}

unsafe impl<'a, Indices, Access> BoundedParAccess<usize> for NarrowedAccess<'a, Indices, Access>
where
    Indices: UniqueIndexList,
    Indices::Index: RecordIndex,
    Access: BoundedParAccess<Indices::Index>,
{
    fn bounds(&self) -> Bounds<usize> {
        Bounds {
            offset: 0,
            extent: self.indices.num_indices(),
        }
    }
}

unsafe impl<'a, Indices, Access> LinearParAccess for NarrowedAccess<'a, Indices, Access>
where
    Indices: UniqueIndexList,
    Indices::Index: RecordIndex,
    Access: BoundedParAccess<Indices::Index>,
{
    #[inline(always)]
    fn collection_len(&self) -> usize {
        self.indices.num_indices()
    }
}