fenris 0.0.33

A library for advanced finite element computations in Rust
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
125
126
127
128
129

use std::any::Any;
use std::cell::RefCell;
use std::thread::LocalKey;

/// A workspace that contains type-erased objects.
///
/// The workspace is intended to hold intermediate data used as workspace in computations.
/// It is optimized particularly for the case where the same type is accessed many times in a row.
///
/// TODO: Tests
#[derive(Debug, Default)]
pub struct Workspace {
    workspaces: Vec<Box<dyn Any>>,
}

impl Workspace {
    pub fn get_or_insert_with<W, F>(&mut self, create: F) -> &mut W
    where
        W: 'static,
        F: FnOnce() -> W,
    {
        // Note: We treat the Vec as a stack, so we search from the end of the vector.
        let existing_ws_idx = self.workspaces.iter().rposition(|ws| ws.is::<W>());
        let idx = match existing_ws_idx {
            Some(idx) => idx,
            None => {
                let w = create();
                let idx = self.workspaces.len();
                self.workspaces.push(Box::new(w) as Box<dyn Any>);
                idx
            }
        };

        // We heuristically assume that the same object is likely to be accessed
        // many times in sequence. Therefore we make sure that the object is the last entry,
        // so that on the next lookup, we'll immediately find the correct object
        let last = self.workspaces.len() - 1;
        self.workspaces.swap(idx, last);

        let entry = &mut self.workspaces[last];
        entry
            .downcast_mut()
            .expect("Internal error: Downcasting can by definition not fail")
    }

    pub fn get_or_default<W>(&mut self) -> &mut W
    where
        W: 'static + Default,
    {
        self.get_or_insert_with(Default::default)
    }
}

/// Runs the provided closure with the thread-local workspace as an argument.
///
/// This simplifies working with [`Workspace`] when it's stored as a thread-local variable.
///
/// Note that the typed workspace must have a [`Default`] implementation.
///
/// # Examples
///
/// ```rust
/// # use std::cell::RefCell;
/// use fenris::workspace::{Workspace, with_thread_local_workspace};
/// use fenris::define_thread_local_workspace;
///
/// define_thread_local_workspace!(WORKSPACE);
///
/// // Workspace must implement Default
/// #[derive(Default)]
/// struct MyWorkspace {
///     buffer: Vec<usize>
/// }
///
/// fn main() {
///     let sum: usize = with_thread_local_workspace(&WORKSPACE, |ws: &mut MyWorkspace| {
///         // This is of course completely nonsense, we just show how you can easily use a thread-local workspace
///         // and produce a result which is returned.
///         ws.buffer.clear();
///         ws.buffer.extend_from_slice(&[1, 4, 3]);
///         ws.buffer.iter().sum()
///     });
///     println!("Sum = {}", sum);
/// }
/// ```
pub fn with_thread_local_workspace<W: 'static + Default, T>(
    workspace: &'static LocalKey<RefCell<Workspace>>,
    f: impl FnOnce(&mut W) -> T,
) -> T {
    workspace.with(|refcell_ws| {
        let mut type_erased_workspace = refcell_ws.borrow_mut();
        let workspace = type_erased_workspace.get_or_default();
        f(workspace)
    })
}

/// Helper macro for easily defining thread-local workspaces.
///
/// # Example
/// ```
/// use fenris::define_thread_local_workspace;
/// use fenris::workspace::with_thread_local_workspace;
///
/// define_thread_local_workspace!(WORKSPACE);
///
/// // Workspace must implement Default
/// #[derive(Default)]
/// struct MyWorkspace {
///     buffer: Vec<usize>
/// }
///
/// fn foo() {
///     with_thread_local_workspace(&WORKSPACE, |workspace: &mut MyWorkspace| {
///         workspace.buffer.clear();
///         workspace.buffer.copy_from_slice(&[1, 2, 3]);
///         // Perform some computations that need intermediate storage
///     })
/// }
/// ```
///
#[macro_export]
macro_rules! define_thread_local_workspace {
    ($variable_name:ident) => {
        thread_local! {
            static $variable_name: std::cell::RefCell<$crate::workspace::Workspace>
                = std::cell::RefCell::new($crate::workspace::Workspace::default());
        }
    };
}