     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

    // Manage the thread-local state, providing access to a `Participant` record.

    use std::sync::atomic::Ordering::Relaxed;

    use mem::epoch::participant::Participant;
    use mem::epoch::global;

    struct LocalEpoch {
        participant: *const Participant,
    }

    impl LocalEpoch {
        fn new() -> LocalEpoch {
            LocalEpoch { participant: global::get().participants.enroll() }
        }

        fn get(&self) -> &Participant {
            unsafe { &*self.participant }
        }
    }

    // FIXME: avoid leaking when all threads have exited
    impl Drop for LocalEpoch {
        fn drop(&mut self) {
            let p = self.get();
            p.enter();
            p.migrate_garbage();
            p.exit();
            p.active.store(false, Relaxed);
        }
    }

    thread_local!(static LOCAL_EPOCH: LocalEpoch = LocalEpoch::new() );

    pub fn with_participant<F, T>(f: F) -> T where F: FnOnce(&Participant) -> T {
        LOCAL_EPOCH.with(|e| f(e.get()))
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)