Method store_panic

src/scope.rs:336–376

(&self, err: Box<dyn Any + Send + 'static>)

    /// counter was incremented by one. This could be through a call to
    /// `add_reference`, a direct `fetch_add` on the underlying counter, or the
    /// implicit initial increment the scope starts with.
    unsafe fn remove_reference(&self) {
        // This is `Release` so that this job's accesses to the scope are
        // ordered before the decrement.
        //
        // The std-lib's `Arc` has the same basic pattern.
        let counter = self.count.fetch_sub(1, Ordering::Release);
        if counter == 1 {
            // This is the final decrement.
            //
            // The `Acquire` fence synchronizes with the release sequence formed
            // by every other job's `Release` decrement of `count`, so all of
            // their accesses to the scope happen-before this point. Combined
            // with the `Release`/`Acquire` handshake in
            // `Latch::set`/`Latch::check`, this orders every job's use of the
            // scope before the owner returns from `complete` and frees it.
            // Without it, remote jobs' atomic ops on `count` (and their reads
            // and writes of `panic`) would race the owner's deallocation.
            fence(Ordering::Acquire);
            // Alerts the owning thread that the scope has completed.
            //
            // This should never panic, because the counter can only go to zero
            // once, when the scope has been dropped and all work has been
            // completed.
            //
            // SAFETY: We meet Variant 2 of the `Latch::set` safety contract:
            //
            // * The count reaches zero exactly once, so this branch runs
            //   exactly once, and this is the only place the latch is set. So
            //   no other call to `set` can race with this one, and `set` cannot
            //   have already been called.
            //
            // * This latch will not be dropped until `complete` returns, and
            //   `complete` will not return until it observes the signal we are
            //   about to send.
            unsafe { Latch::set(&self.completed, false) };
        }
    }

    /// Stores a panic so that it can be propagated when the scope is complete.
    /// If called multiple times, only the first panic is stored, and the
    /// remainder are dropped.
    ///
    /// This function never unwinds, but may abort in circumstances.