sync-cell-slice 0.9.9

Cells and slices that are accessible from multiple threads
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

# Sync cells and slices

[![downloads](https://img.shields.io/crates/d/sync-cell-slice)](https://crates.io/crates/sync-cell-slice)
[![dependents](https://img.shields.io/librariesio/dependents/cargo/sync-cell-slice)](https://crates.io/crates/sync-cell-slice/reverse_dependencies)
![license](https://img.shields.io/crates/l/sync-cell-slice)
[![](https://tokei.rs/b1/github/vigna/sync-cell-slice-rs?type=Rust)](https://github.com/vigna/sync-cell-slice-rs)
[![Latest version](https://img.shields.io/crates/v/sync-cell-slice.svg)](https://crates.io/crates/sync-cell-slice)
[![Documentation](https://docs.rs/sync-cell-slice/badge.svg)](https://docs.rs/sync-cell-slice)

Sometimes, multiple threads needs to access a place or an element of a slice
without atomic operations because the absence of data races is guaranteed
externally (e.g., each threads writes to a different element of the slice).

This small crate implements a solution based on a [`SyncCell<T>`] newtype with
base type [`Cell<T>`]. Contrarily to [`Cell<T>`], [`SyncCell<T>`] can be shared
among threads, as long as its content can be shared, too. This result is
obtained by forcing [`Sync`] on [`SyncCell<T>`] if `T` is [`Sync`].

All access methods are unsafe, because lack of external synchronization might
lead to data races, and thus to undefined behavior. Note that this approach is
radically different from that of [`SyncUnsafeCell`], all of which methods are
safe.

An important advantage of using [`Cell`] instead of [`UnsafeCell`] as base type
is that we can use the [`Cell::as_slice_of_cells`] method to make [`SyncCell`]
and slices commute, that is, to obtain (safely) from a reference to
a `SyncCell<[T]>` a reference to a `[SyncCell<T>]`. Since [`SyncCell<T>`] is
[`Sync`] if `T` is, `[SyncCell<T>]` is [`Sync`] if `T` is, too. Thus, if `T` is
 [`Sync`] sharing a slice of `T` among threads is just a matter of wrapping the
slice in a `SyncCell` and calling [`SyncCell::as_slice_of_cells`]. This process
is carried out by the extension trait [`SyncSlice`], which add to slices a
method [`as_sync_slice`].

The design is based on suggestions contained in a [post by Alice
Ryhl](https://stackoverflow.com/questions/65178245/how-do-i-write-to-a-mutable-slice-from-multiple-threads-at-arbitrary-indexes-wit/65182786#65182786)
and in this [thread on the Rust Language
Forum](https://users.rust-lang.org/t/parallel-interior-mutability/121542/7).

## Acknowledgements

This software has been partially supported by project SERICS (PE00000014) under
the NRRP MUR program funded by the EU - NGEU. Views and opinions expressed are
however those of the authors only and do not necessarily reflect those of the
European Union or the Italian MUR. Neither the European Union nor the Italian
MUR can be held responsible for them.

[`SyncUnsafeCell`]: <https://doc.rust-lang.org/std/cell/struct.SyncUnsafeCell.html>
[`as_sync_slice`]: <https://docs.rs/sync-cell-slice/latest/sync_cell_slice/trait.SyncSlice.html#tymethod.as_sync_slice>
[`Cell<T>`]: <https://doc.rust-lang.org/std/cell/struct.Cell.html>
[`Cell`]: <https://doc.rust-lang.org/std/cell/struct.Cell.html>
[`UnsafeCell`]: <https://doc.rust-lang.org/std/cell/struct.UnsafeCell.html>
[`Cell::as_slice_of_cells`]: <https://doc.rust-lang.org/std/cell/struct.Cell.html#method.as_slice_of_cells>
[`SyncCell`]: <https://docs.rs/sync-cell-slice/latest/sync_cell_slice/struct.SyncCell.html>
[`SyncCell::as_slice_of_cells`]: <https://docs.rs/sync-cell-slice/latest/sync_cell_slice/struct.SyncCell.html#method.as_slice_of_cells>
[`SyncSlice`]: <https://docs.rs/sync-cell-slice/latest/sync_cell_slice/trait.SyncSlice.html>
[`Sync`]: <https://doc.rust-lang.org/std/marker/trait.Sync.html>
[`SyncCell<T>`]: <https://docs.rs/sync-cell-slice/latest/sync_cell_slice/struct.SyncCell.html>