diff --git a/bagpipe/CHANGELOG.md b/bagpipe/CHANGELOG.md
index d468322..db4dfb2 100644
--- a/bagpipe/CHANGELOG.md
+++ b/bagpipe/CHANGELOG.md
@@ -1,4 +1,4 @@
-<!-- Copyright 2017 the authors. See the 'Copyright and license' section of the
+<!-- Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 README.md file at the top-level directory of this repository.
 
 Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -19,6 +19,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
   not happen automatically, but there is a new trait to inject cleanup callbacks
   to `BagPipe` shutdown.
 
+### Changed
+- Bagpipes now store a Crossbeam Epoch GC instance rather than using the global
+  singleton instance so that using a Bagpipe does not rely on thread-local
+  storage.
+
 ### Fixed
 - Fixed a bug where crossbeam TLS would remain uninitialized upon cloning a
   `BagPipe`, resulting in stack overflow in `elfmalloc`.
diff --git a/bagpipe/Cargo.toml b/bagpipe/Cargo.toml
index a534e8a..db8140f 100644
--- a/bagpipe/Cargo.toml
+++ b/bagpipe/Cargo.toml
@@ -1,4 +1,4 @@
-# Copyright 2017 the authors. See the 'Copyright and license' section of the
+# Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 # README.md file at the top-level directory of this repository.
 #
 # Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -31,4 +31,5 @@ huge_segments = []
 
 [dependencies]
 crossbeam = "0.2"
+crossbeam-epoch = "0.4.0"
 num_cpus = "1.5"
diff --git a/bagpipe/src/bag.rs b/bagpipe/src/bag.rs
index 9736c23..18dd166 100644
--- a/bagpipe/src/bag.rs
+++ b/bagpipe/src/bag.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -8,7 +8,7 @@
 //! Specification of best-effort bags and implementation for `crossbeam`
 //! data-structures.
 use super::crossbeam::sync::{TreiberStack, SegQueue, MsQueue};
-use super::crossbeam::mem::epoch;
+use super::crossbeam_epoch::{default_handle, Handle};
 use std::sync::atomic::AtomicUsize;
 use std::sync::Arc;
 
@@ -22,27 +22,47 @@ pub enum PopStatus {
 
 pub type PopResult<T> = Result<T, PopStatus>;
 
-
 /// A best-effort Bag data-structure.
 ///
 /// As embodied in the `PopResult` definition, `try_pop` is permitted to
 /// fail even if the bag in question is not empty.
-pub trait SharedWeakBag {
+pub trait SharedWeakBag where Self: Sized {
     type Item;
+
+    fn new_gc(handle: &Handle) -> Self;
+
     /// Returns a new instance of the data-structure.
-    fn new() -> Self;
+    fn new() -> Self {
+        Self::new_gc(&default_handle())
+    }
+
+    fn try_push_gc(&self, handle: &Handle, it: Self::Item) -> Result<(), Self::Item>;
 
     /// Attempts to push `it` onto the data-structure.
     ///
     /// If successful, `try_push` will return `true`.
-    fn try_push(&self, it: Self::Item) -> Result<(), Self::Item>;
+    fn try_push(&self, it: Self::Item) -> Result<(), Self::Item> {
+        self.try_push_gc(&default_handle(), it)
+    }
+
+    fn try_pop_gc(&self, handle: &Handle) -> PopResult<Self::Item>;
 
     /// Attempts to pop a value from the data-structure.
     ///
     /// There is no guaranteed ordering of popped values. This method
     /// may fail arbitrarily even if there are accessible values in the
     /// data-structure.
-    fn try_pop(&self) -> PopResult<Self::Item>;
+    fn try_pop(&self) -> PopResult<Self::Item> {
+        self.try_pop_gc(&default_handle())
+    }
+
+    fn push_gc(&self, handle: &Handle, it: Self::Item) {
+        let _g = handle.pin();
+        let mut cur_item = it;
+        while let Err(old_item) = self.try_push_gc(handle, cur_item) {
+            cur_item = old_item
+        }
+    }
 
     /// A push operation that will not fail.
     ///
@@ -54,20 +74,13 @@ pub trait SharedWeakBag {
     /// `push` also creates a `Guard` for the duration of the function
     /// to avoid excessive checking in the hot loop.
     fn push(&self, it: Self::Item) {
-        let _g = epoch::pin();
-        let mut cur_item = it;
-        while let Err(old_item) = self.try_push(cur_item) {
-            cur_item = old_item
-        }
+        self.push_gc(&default_handle(), it)
     }
 
-    /// A pop operation that will not fail.
-    ///
-    /// Same caveats apply to those of `push`.
-    fn pop(&self) -> Option<Self::Item> {
-        let _g = epoch::pin();
+    fn pop_gc(&self, handle: &Handle) -> Option<Self::Item> {
+        let _g = handle.pin();
         loop {
-            return match self.try_pop() {
+            return match self.try_pop_gc(handle) {
                 Ok(it) => Some(it),
                 Err(PopStatus::Empty) => None,
                 Err(PopStatus::TransientFailure) => continue,
@@ -75,6 +88,13 @@ pub trait SharedWeakBag {
         }
     }
 
+    /// A pop operation that will not fail.
+    ///
+    /// Same caveats apply to those of `push`.
+    fn pop(&self) -> Option<Self::Item> {
+        self.pop_gc(&default_handle())
+    }
+
     fn debug(&self) {}
 }
 
@@ -88,18 +108,18 @@ pub trait SharedWeakBag {
 pub trait WeakBag: Clone {
     // TODO(ezrosent): should we keep Clone here?
     type Item;
-    // fn new() -> Self;
+
     fn try_push_mut(&mut self, Self::Item) -> Result<(), Self::Item>;
     fn try_pop_mut(&mut self) -> PopResult<Self::Item>;
     fn push_mut(&mut self, it: Self::Item) {
-        let _g = epoch::pin();
+        // TODO(joshlf): Pin the WeakBag's GC for performance
         let mut cur_item = it;
         while let Err(old_item) = self.try_push_mut(cur_item) {
             cur_item = old_item
         }
     }
     fn pop_mut(&mut self) -> Option<Self::Item> {
-        let _g = epoch::pin();
+        // TODO(joshlf): Pin the WeakBag's GC for performance
         loop {
             return match self.try_pop_mut() {
                 Ok(it) => Some(it),
@@ -197,14 +217,17 @@ where
 
 impl<T> SharedWeakBag for TreiberStack<T> {
     type Item = T;
-    fn new() -> Self {
+
+    fn new_gc(_handle: &Handle) -> Self {
         Self::new()
     }
-    fn try_push(&self, t: T) -> Result<(), T> {
+
+    fn try_push_gc(&self, _handle: &Handle, t: T) -> Result<(), T> {
         self.push(t);
         Ok(())
     }
-    fn try_pop(&self) -> PopResult<T> {
+
+    fn try_pop_gc(&self, _handle: &Handle) -> PopResult<T> {
         match self.pop() {
             Some(res) => Ok(res),
             None => Err(PopStatus::Empty),
@@ -214,14 +237,17 @@ impl<T> SharedWeakBag for TreiberStack<T> {
 
 impl<T> SharedWeakBag for SegQueue<T> {
     type Item = T;
-    fn new() -> Self {
+
+    fn new_gc(_handle: &Handle) -> Self {
         Self::new()
     }
-    fn try_push(&self, t: T) -> Result<(), T> {
+
+    fn try_push_gc(&self, _handle: &Handle, t: T) -> Result<(), T> {
         self.push(t);
         Ok(())
     }
-    fn try_pop(&self) -> PopResult<T> {
+
+    fn try_pop_gc(&self, _handle: &Handle) -> PopResult<T> {
         match self.try_pop() {
             Some(res) => Ok(res),
             None => Err(PopStatus::Empty),
@@ -231,14 +257,17 @@ impl<T> SharedWeakBag for SegQueue<T> {
 
 impl<T> SharedWeakBag for MsQueue<T> {
     type Item = T;
-    fn new() -> Self {
+
+    fn new_gc(_handle: &Handle) -> Self {
         Self::new()
     }
-    fn try_push(&self, t: T) -> Result<(), T> {
+
+    fn try_push_gc(&self, _handle: &Handle, t: T) -> Result<(), T> {
         self.push(t);
         Ok(())
     }
-    fn try_pop(&self) -> PopResult<T> {
+
+    fn try_pop_gc(&self, _handle: &Handle) -> PopResult<T> {
         match self.try_pop() {
             Some(res) => Ok(res),
             None => Err(PopStatus::Empty),
diff --git a/bagpipe/src/bin/bench_bag.rs b/bagpipe/src/bin/bench_bag.rs
index 6f01576..cb631ce 100644
--- a/bagpipe/src/bin/bench_bag.rs
+++ b/bagpipe/src/bin/bench_bag.rs
@@ -52,7 +52,7 @@ fn enqueue_dequeue_pairs_usize<W>(npairs: usize,
                                   prefill_with: usize,
                                   description: String)
                                   -> WorkloadStats
-    where W: WeakBag<Item = usize> + Send + Sync + 'static + Default
+    where W: WeakBag<Item = usize> + Send + 'static + Default
 {
     let wb = W::default();
     for i in 0..prefill_with {
@@ -113,7 +113,7 @@ fn enqueue_dequeue_pairs_strong<W>(npairs: usize,
                                    prefill_with: usize,
                                    description: String)
                                    -> WorkloadStats
-    where W: WeakBag<Item = usize> + Send + Sync + 'static + Default
+    where W: WeakBag<Item = usize> + Send + 'static + Default
 {
     let wb = W::default();
     for i in 0..prefill_with {
@@ -168,7 +168,7 @@ fn producer_consumer_strong<W>(npairs: usize,
                                prefill_with: usize,
                                description: String)
                                -> WorkloadStats
-    where W: WeakBag<Item = usize> + Send + Sync + 'static + Default
+    where W: WeakBag<Item = usize> + Send + 'static + Default
 {
     let wb = W::default();
     for i in 0..prefill_with {
@@ -238,7 +238,7 @@ fn enqueue_dequeue_usize<W>(npairs: usize,
                             prefill_with: usize,
                             description: String)
                             -> WorkloadStats
-    where W: WeakBag<Item = usize> + Send + Sync + 'static + Default
+    where W: WeakBag<Item = usize> + Send + 'static + Default
 {
     let wb = W::default();
     for i in 0..prefill_with {
diff --git a/bagpipe/src/lib.rs b/bagpipe/src/lib.rs
index 969233e..8c728fc 100644
--- a/bagpipe/src/lib.rs
+++ b/bagpipe/src/lib.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -65,12 +65,14 @@
 //! soon.
 
 extern crate crossbeam;
+extern crate crossbeam_epoch;
 extern crate num_cpus;
 use std::marker::PhantomData;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, AtomicIsize, Ordering, fence};
 use bag::{WeakBag, SharedWeakBag, RevocableWeakBag, Revocable, PopResult, PopStatus};
 use crossbeam::mem::CachePadded;
+use crossbeam_epoch::Collector;
 use std::mem;
 
 pub mod queue;
@@ -130,6 +132,7 @@ where
     Clean: BagCleanup<Item = B::Item>,
 {
     pipes: Arc<BagPipeState<B, Clean>>,
+    gc: crossbeam_epoch::Handle,
     offset: usize,
     stride: usize,
     push_failures: usize,
@@ -153,7 +156,8 @@ impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> Clone for BagPipe<B, C
         // handle for elfmalloc is initialized, reentrancy guards are no longer checked; this
         // forces later calls to elfmalloc that require EBMR to initialize TLS, and call malloc:
         // resulting in a recursive malloc call that blows out the stack.
-        let _ = crossbeam::mem::epoch::pin();
+        let _ = self.gc.pin();
+
         #[cfg(feature="prime_schedules")]
         let offset = {
             primes::get(self.pipes.all_refs.fetch_add(1, Ordering::Relaxed) + 1)
@@ -165,6 +169,7 @@ impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> Clone for BagPipe<B, C
         };
         BagPipe {
             pipes: self.pipes.clone(),
+            gc: self.pipes.gc.handle(),
             offset: offset & (self.pipes.pipes.len() - 1),
             stride: offset,
             push_failures: 0,
@@ -181,9 +186,14 @@ impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> BagPipe<B, Clean> {
         #[cfg(not(feature="prime_schedules"))]
         let offset = 1;
         debug_assert!(size > 0);
+
+        let pipes = Arc::new(BagPipeState::new_size(size, clean));
+        let gc = pipes.gc.handle();
+
         BagPipe {
-            pipes: Arc::new(BagPipeState::new_size(size, clean)),
-            offset: offset,
+            pipes,
+            gc,
+            offset,
             stride: offset,
             push_failures: 0,
             pop_failures: 0,
@@ -252,9 +262,14 @@ impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item> + Default> BagPipe<B, C
         let offset = primes::get(1);
         #[cfg(not(feature="prime_schedules"))]
         let offset = 1;
+
+        let pipes = Arc::new(BagPipeState::new(Clean::default()));
+        let gc = pipes.gc.handle();
+
         BagPipe {
-            pipes: Arc::new(BagPipeState::new(Clean::default())),
-            offset: offset,
+            pipes,
+            gc,
+            offset,
             stride: offset,
             push_failures: 0,
             pop_failures: 0,
@@ -382,6 +397,7 @@ struct BagPipeState<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> {
     counters: [CachePadded<AtomicIsize>; N_COUNTERS],
     pipes: Vec<B>,
     clean: Clean,
+    gc: Collector,
 }
 
 impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> Drop for BagPipeState<B, Clean> {
@@ -400,6 +416,7 @@ impl<B: SharedWeakBag, Clean: BagCleanup<Item = B::Item>> BagPipeState<B, Clean>
             counters: unsafe { mem::transmute([[0 as usize; 32]; N_COUNTERS]) },
             pipes: Vec::with_capacity(len),
             clean: clean,
+            gc: Collector::new(),
         };
         for _ in 0..len {
             res.pipes.push(B::new())
diff --git a/bagpipe/src/queue.rs b/bagpipe/src/queue.rs
index 43d1cdd..65dc9d9 100644
--- a/bagpipe/src/queue.rs
+++ b/bagpipe/src/queue.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 the authors. See the 'Copyright and license' section of the
+// Copyright 2017-2018 the authors. See the 'Copyright and license' section of the
 // README.md file at the top-level directory of this repository.
 //
 // Licensed under the Apache License, Version 2.0 (the LICENSE-APACHE file) or
@@ -28,8 +28,8 @@
 //! respectively) both for benchmarking purposes and to facilitate
 //! documentation; it does not seem possible to generate custom doc
 //! comments for those data-structures.
-use super::crossbeam::mem::epoch::{Shared, Atomic, Owned, Guard};
-use super::crossbeam::mem::epoch;
+
+use super::crossbeam_epoch::{Handle, Shared, Atomic, Owned, Guard};
 use super::crossbeam::mem::CachePadded;
 use bag::{PopResult, PopStatus, SharedWeakBag, Revocable, RevocableWeakBag};
 use std::sync::atomic::{AtomicUsize, Ordering, fence};
@@ -211,15 +211,21 @@ pub struct YangCrummeyQueue<T: Node> {
     tail_index: CachePadded<AtomicUsize>,
     head_data: CachePadded<Atomic<Segment<T>>>,
     tail_data: CachePadded<Atomic<Segment<T>>>,
+
+    // We only ever use this Handle on drop. All other methods take a handle reference. While
+    // Handles are not Sync, that's OK because drop takes a mutable reference and is only called by
+    // a single thread at a time.
+    gc: Handle,
 }
 
 impl<T: Node> Drop for YangCrummeyQueue<T> {
     fn drop(&mut self) {
         // This method will do very bad things if it ever gets called
         // with parts of the queue still reachable.
-        let guard = epoch::pin();
-        let head = self.head_data.load(Ordering::Relaxed, &guard).unwrap();
-        let tail = self.tail_data.load(Ordering::Relaxed, &guard).unwrap();
+        let guard = self.gc.pin();
+
+        let head = unsafe { self.head_data.load(Ordering::Relaxed, &guard).deref() };
+        let tail = unsafe { self.tail_data.load(Ordering::Relaxed, &guard).deref() };
         let mut cur_node = if head.id.load(Ordering::Relaxed) < tail.id.load(Ordering::Relaxed) {
             head
         } else {
@@ -227,12 +233,13 @@ impl<T: Node> Drop for YangCrummeyQueue<T> {
         };
         loop {
             unsafe {
-                guard.unlinked(cur_node);
+                guard.defer(move || mem::drop(cur_node));
             }
-            match cur_node.next.load(Ordering::Relaxed, &guard) {
-                Some(shared) => cur_node = shared,
-                None => break,
+            let shared = cur_node.next.load(Ordering::Relaxed, &guard);
+            if shared.is_null() {
+                break;
             }
+            cur_node = unsafe { shared.deref() };
         }
     }
 }
@@ -249,28 +256,28 @@ impl<T: Node> YangCrummeyQueue<T> {
     /// corresponding memory if necessary.
     fn try_cleanup<'a>(&self, seg: &Atomic<Segment<T>>, data: Shared<'a, Segment<T>>, g: &Guard) {
         // TODO(ezr) relaxed semantics may be sufficient here.
-        let next = data.next.load(Ordering::Acquire, g);
+        let next = unsafe { data.deref().next.load(Ordering::Acquire, g) };
         // if next is null, then it means that something very strange
         // has happened and it is best to walk away. Recall that
         // try_cleanup is only called if some thread actually followed
         // seg's next pointer. Even for a very long stall in execution,
         // some segment must be there. Given the use of relaxed ordering
         // in push and pop I am not sure that this can be ruled out.
-        if next.is_some()
+        if !next.is_null()
             // next we try and CAS data to its next pointer. If this
             // fails it means someone else succeeded and we can just
             // return.
-            && seg.cas_shared(Some(data), next, Ordering::Release)
+            && seg.compare_and_set(data, next, Ordering::Release, g).is_ok()
             // finally, we increment the counter of times this value
             // has advanced. data.ctr is a sort of "inverse ref count";
             // it avoids a double-free with head_data and tail_data
             // advancing past the same segment. Whoever advances the
             // pointer last is obligated to reclaim the memory.
-            && data.ctr.fetch_add(1, Ordering::AcqRel) == 1
+            && unsafe { data.deref().ctr.fetch_add(1, Ordering::AcqRel) == 1 }
         {
             // we are the second pointer to advance past this segment,
             // so we reclaim the memory.
-            unsafe { g.unlinked(data) }
+            unsafe { g.defer(move || mem::drop(data)) }
         }
     }
 
@@ -283,16 +290,15 @@ impl<T: Node> YangCrummeyQueue<T> {
         seg: &Atomic<Segment<T>>,
         g: &'a Guard,
     ) -> (usize, &'a AtomicUsize) {
-        let data = seg.load(Ordering::Relaxed, g).expect(
-            "initial pointer should never be null",
-        );
-        let cur_id = data.id.load(Ordering::Relaxed);
+        let data = seg.load(Ordering::Relaxed, g);
+        assert!(!data.is_null());
+        let cur_id = unsafe { data.deref().id.load(Ordering::Relaxed) };
         // the load of data must happen before the fetch-add of ix,
         // otherwise we are in danger of the pointer being advanced
         // between ix being incremented data being loaded.
         fence(Ordering::Acquire);
         let ix = ind.fetch_add(1, Ordering::Relaxed);
-        let (node_ref, try_clean) = data.find_cell(ix, g);
+        let (node_ref, try_clean) = unsafe { data.deref().find_cell(ix, g) };
         let res = node_to_atomic_ref!(node_ref);
         // only try to clean up if ix corresponds to the first index
         // past cur_id.
@@ -314,28 +320,28 @@ impl<T: Node> YangCrummeyQueue<T> {
     }
 }
 
-
 impl<T: Node> SharedWeakBag for YangCrummeyQueue<T> {
     type Item = T;
 
-    fn new() -> Self {
-        let guard = epoch::pin();
+    fn new_gc(handle: &Handle) -> Self {
+        let guard = handle.pin();
         // Initialize head and tail pointers to point to the same location.
         let res = YangCrummeyQueue {
             head_index: CachePadded::new(AtomicUsize::new(0)),
             tail_index: CachePadded::new(AtomicUsize::new(0)),
             head_data: CachePadded::new(Atomic::new(Segment::new(0))),
             tail_data: CachePadded::new(Atomic::null()),
+            gc: handle.clone(),
         };
-        res.tail_data.store_shared(
+        res.tail_data.store(
             res.head_data.load(Ordering::SeqCst, &guard),
             Ordering::Release,
         );
         res
     }
 
-    fn try_push(&self, t: T) -> Result<(), T> {
-        let guard = epoch::pin();
+    fn try_push_gc(&self, handle: &Handle, t: T) -> Result<(), T> {
+        let guard = handle.pin();
         let (_, cell) = self.increment_and_get_usize(&self.tail_index, &self.tail_data, &guard);
         // XXX: can this be an exchange instead of a CAS?
         let res = cell.swap(t.as_usize(), Ordering::Relaxed);
@@ -343,14 +349,14 @@ impl<T: Node> SharedWeakBag for YangCrummeyQueue<T> {
         if res == 0 { Ok(()) } else { Err(t) }
     }
 
-    fn try_pop(&self) -> PopResult<T> {
+    fn try_pop_gc(&self, handle: &Handle) -> PopResult<T> {
         #[cfg(feature = "check_empty_yq")]
         {
             if self.is_empty() {
                 return Err(PopStatus::Empty);
             }
         }
-        let guard = epoch::pin();
+        let guard = handle.pin();
         let (ix, cell) = self.increment_and_get_usize(&self.head_index, &self.head_data, &guard);
         let res = cell.swap(SENTINEL, Ordering::Relaxed);
         debug_assert_ne!(res, SENTINEL);
@@ -433,25 +439,24 @@ impl<T: Node> Segment<T> {
             }
             not_first = true;
             // our target segment is further in the list.
-            match cur_seg.next.load(Ordering::Relaxed, guard) {
-                // search in the next segment.
-                Some(shared) => cur_seg = *shared,
+            let next = cur_seg.next.load(Ordering::Relaxed, guard);
+            if next.is_null() {
                 // There is no next segment, attempt to create it. If
                 // this compare-and-swap fails it means that someone
                 // else suceeded, so we just retry.
-                None => {
-                    let new_seg = Owned::new(Segment::new(cur_id + 1));
-                    // TODO(ezr) don't waste the allocation?
-                    if let Ok(shared) = cur_seg.next.cas_and_ref(
-                        None,
-                        new_seg,
-                        Ordering::Relaxed,
-                        guard,
-                    )
-                    {
-                        cur_seg = *shared;
-                    }
+                let new_seg = Owned::new(Segment::new(cur_id + 1));
+                // TODO(ezr) don't waste the allocation?
+                if let Ok(shared) = cur_seg.next.compare_and_set(
+                    Shared::null(),
+                    new_seg,
+                    Ordering::Relaxed,
+                    guard,
+                )
+                {
+                    cur_seg = unsafe { shared.deref() };
                 }
+            } else {
+                cur_seg = unsafe { next.deref() };
             }
         }
         (unsafe { cur_seg.data.get_unchecked(seg_ix) }, not_first)
@@ -510,13 +515,16 @@ impl<T> RevokeFunc<T> for () {
 
 impl<T: Node, F: RevokeFunc<T> + 'static> Drop for FAAQueueLowLevel<T, F> {
     fn drop(&mut self) {
-        let guard = epoch::pin();
+        // TODO(joshlf): Can this just be a dummy guard?
+        let guard = ::crossbeam_epoch::pin();
         let mut cur_node = &self.head;
-        while let Some(n) = cur_node.load(Ordering::Relaxed, &guard) {
+        let mut n = cur_node.load(Ordering::Relaxed, &guard);
+        while !n.is_null() {
             unsafe {
-                guard.unlinked(n);
+                guard.defer(move || mem::drop(n));
             }
-            cur_node = &n.next;
+            cur_node = unsafe { &n.deref().next };
+            n = cur_node.load(Ordering::Relaxed, &guard);
         }
     }
 }
@@ -537,28 +545,28 @@ impl<T: Node + Revocable + 'static> RevocableWeakBag for FAAQueueLowLevel<T, Rev
 
 impl<T: Node, F: RevokeFunc<T> + 'static> SharedWeakBag for FAAQueueLowLevel<T, F> {
     type Item = T;
-    fn new() -> Self {
+
+    fn new_gc(handle: &Handle) -> Self {
         let res = FAAQueueLowLevel {
             head: CachePadded::new(Atomic::new(FAANode::new_empty())),
             tail: CachePadded::new(Atomic::null()),
             _marker: PhantomData,
         };
-        let guard = epoch::pin();
-        res.tail.store_shared(
+        let guard = handle.pin();
+        res.tail.store(
             res.head.load(Ordering::Relaxed, &guard),
             Ordering::Relaxed,
         );
         res
     }
 
-    fn try_push(&self, item: T) -> Result<(), T> {
-        let guard = epoch::pin();
+    fn try_push_gc(&self, handle: &Handle, item: T) -> Result<(), T> {
+        let guard = handle.pin();
         let it = item.as_usize();
         loop {
-            let tail = self.tail.load(Ordering::Relaxed, &guard).expect(
-                "tail pointer should not be null",
-            );
-            let ix = tail.tail_index.fetch_add(1, Ordering::Relaxed);
+            let tail = self.tail.load(Ordering::Relaxed, &guard);
+            assert!(!tail.is_null());
+            let ix = unsafe { tail.deref().tail_index.fetch_add(1, Ordering::Relaxed) };
             if ix >= SMALL_SEG_SIZE {
                 // We need to enqueue in a cell further in the linked list.
                 //
@@ -566,46 +574,44 @@ impl<T: Node, F: RevokeFunc<T> + 'static> SharedWeakBag for FAAQueueLowLevel<T,
                 if !self.is_tail(tail, &guard) {
                     continue;
                 }
-                match tail.next.load(Ordering::Relaxed, &guard) {
-                    Some(next) => {
-                        // There is an item after the current tail, we try and assign it to the
-                        // value of the tail. Regardless of the success of the CAS, there will be
-                        // something new in the value of the tail, so we reload.
-                        self.tail.cas_shared(
-                            Some(tail),
-                            Some(next),
-                            Ordering::Relaxed,
-                        );
-                        continue;
-                    }
-
-                    None => {
-                        // There is nothing in the tail value, so we attempt to allocate a new node
-                        // beginning with our item.
-                        let new_node = Owned::new(FAANode::new(Node::from_usize(it)));
-                        if let Ok(shared) = tail.next.cas_and_ref(
-                            None,
+                let next = unsafe { tail.deref().next.load(Ordering::Relaxed, &guard) };
+                if next.is_null() {
+                    // There is nothing in the tail value, so we attempt to allocate a new node
+                    // beginning with our item.
+                    let new_node = Owned::new(FAANode::new(Node::from_usize(it)));
+                    if let Ok(new_node) = unsafe { tail.deref().next.compare_and_set(
+                        Shared::null(),
+                        new_node,
+                        Ordering::Relaxed,
+                        &guard,
+                    ) } {
+                        // We succeeded. We try to CAS tail to our new segment but either way
+                        // we can return success.
+                        let _ = self.tail.compare_and_set(
+                            tail,
                             new_node,
                             Ordering::Relaxed,
                             &guard,
-                        )
-                        {
-                            // We succeeded. We try to CAS tail to our new segment but either way
-                            // we can return success.
-                            self.tail.cas_shared(
-                                Some(tail),
-                                Some(shared),
-                                Ordering::Relaxed,
-                            );
-                            return Ok(());
-                        }
-                        // We failed, but that means another node is there, so we retry.
+                        );
+                        return Ok(());
                     }
+                    // We failed, but that means another node is there, so we retry.
+                } else {
+                    // There is an item after the current tail, we try and assign it to the
+                    // value of the tail. Regardless of the success of the CAS, there will be
+                    // something new in the value of the tail, so we reload.
+                    let _ = self.tail.compare_and_set(
+                        tail,
+                        next,
+                        Ordering::Relaxed,
+                        &guard,
+                    );
+                    continue;
                 }
                 continue;
             }
             // ix is within range. We try and swap in our value.
-            let cell_ref = unsafe { tail.get(ix) };
+            let cell_ref = unsafe { tail.deref().get(ix) };
             // store revocation information if available.
             F::store(&item, cell_ref as *const _ as *mut T as usize);
             let res = cell_ref.compare_and_swap(0, it, Ordering::Relaxed);
@@ -622,53 +628,51 @@ impl<T: Node, F: RevokeFunc<T> + 'static> SharedWeakBag for FAAQueueLowLevel<T,
         }
     }
 
-    fn try_pop(&self) -> PopResult<T> {
-        let guard = epoch::pin();
+    fn try_pop_gc(&self, handle: &Handle) -> PopResult<T> {
+        let guard = handle.pin();
         loop {
-            let head = self.head.load(Ordering::Relaxed, &guard).expect(
-                "head pointer should not be null",
-            );
+            let head = self.head.load(Ordering::Relaxed, &guard);
+            assert!(!head.is_null());
             // First we check if the queue is empty. To do this we load the head and then the tail.
             // This is because both values can only increase, but if tail_ix is less than what
             // head_ix was in the past, the queue is still empty regardless (because no concurrent
             // pop could increment head).
-            let head_ix = head.head_index.load(Ordering::Relaxed);
+            let head_ix = unsafe { head.deref().head_index.load(Ordering::Relaxed) };
             fence(Ordering::Acquire);
-            let tail_ix = head.tail_index.load(Ordering::Relaxed);
-            let tail_ptr = head.next.load(Ordering::Relaxed, &guard);
-            if head_ix >= tail_ix && tail_ptr.is_none() {
+            let tail_ix = unsafe { head.deref().tail_index.load(Ordering::Relaxed) };
+            let tail_ptr = unsafe { head.deref().next.load(Ordering::Relaxed, &guard) };
+            if head_ix >= tail_ix && tail_ptr.is_null() {
                 return Err(PopStatus::Empty);
             }
             // Now we acquire a location in the cell.
-            let my_ix = head.head_index.fetch_add(1, Ordering::Relaxed);
+            let my_ix = unsafe { head.deref().head_index.fetch_add(1, Ordering::Relaxed) };
             if my_ix >= SMALL_SEG_SIZE {
                 // We are past the end, time to see if there is anything forward in the list.
-                match head.next.load(Ordering::Relaxed, &guard) {
-                    Some(shared) => {
-                        // There is something, we try and CAS the head to it and retry. Because
-                        // this segment is now exhausted, we mark it as unlinked. Why is this safe?
-                        // because we already confirmed that the queue is non-empty. This means
-                        // that either all active dequeue threads will either look to the next node
-                        // already, or have an active guard.
-                        //
-                        // TODO(ezrosent): confirm this reasoning.
-                        if self.head.cas_shared(
-                            Some(head),
-                            Some(shared),
-                            Ordering::Relaxed,
-                        )
-                        {
-                            unsafe { guard.unlinked(head) };
-                        }
-                        continue;
-                    }
-                    None => {
-                        return Err(PopStatus::Empty);
+                let next = unsafe { head.deref().next.load(Ordering::Relaxed, &guard) };
+                if next.is_null() {
+                    return Err(PopStatus::Empty);
+                } else {
+                    // There is something, we try and CAS the head to it and retry. Because
+                    // this segment is now exhausted, we mark it as unlinked. Why is this safe?
+                    // because we already confirmed that the queue is non-empty. This means
+                    // that either all active dequeue threads will either look to the next node
+                    // already, or have an active guard.
+                    //
+                    // TODO(ezrosent): confirm this reasoning.
+                    if self.head.compare_and_set(
+                        head,
+                        next,
+                        Ordering::Relaxed,
+                        &guard,
+                    ).is_ok()
+                    {
+                        unsafe { guard.defer(move || mem::drop(head)) };
                     }
-                };
+                    continue;
+                }
             }
             // Now we try and swap sentinel into our chosen location.
-            let res = unsafe { head.get(my_ix).swap(SENTINEL, Ordering::Relaxed) };
+            let res = unsafe { head.deref().get(my_ix).swap(SENTINEL, Ordering::Relaxed) };
             return if res == 0 || res == SENTINEL {
                 // revocations can put SENTINEL in any cell
                 Err(PopStatus::TransientFailure)
@@ -685,7 +689,7 @@ impl<T: Node, F: RevokeFunc<T> + 'static> SharedWeakBag for FAAQueueLowLevel<T,
 
 impl<T: Node, F: RevokeFunc<T> + 'static> FAAQueueLowLevel<T, F> {
     fn is_tail<'a>(&self, ptr: Shared<'a, FAANode<T>>, guard: &'a Guard) -> bool {
-        let raw_ptr = self.tail.load(Ordering::Relaxed, guard).unwrap();
+        let raw_ptr = self.tail.load(Ordering::Relaxed, guard);
         ptr.as_raw() == raw_ptr.as_raw()
     }
 }
@@ -728,20 +732,20 @@ macro_rules! generalize {
         impl<T: Sized> SharedWeakBag for $newty<T> {
             type Item = T;
 
-            fn new() -> Self {
+            fn new_gc(_handle: &Handle) -> Self {
                 $newty($curty::new())
             }
 
-            fn try_push(&self, t: T) -> Result<(), T> {
+            fn try_push_gc(&self, handle: &Handle, t: T) -> Result<(), T> {
                 let raw_t: *mut T = Box::into_raw(Box::new(t));
-                match self.0.try_push(raw_t) {
+                match self.0.try_push_gc(handle, raw_t) {
                     Ok(()) => Ok(()),
                     Err(it) => unsafe { Err(*Box::from_raw(it)) },
                 }
             }
 
-            fn try_pop(&self) -> PopResult<T> {
-                match self.0.try_pop() {
+            fn try_pop_gc(&self, handle: &Handle) -> PopResult<T> {
+                match self.0.try_pop_gc(handle) {
                     Ok(raw_ptr) => unsafe { Ok(*Box::from_raw(raw_ptr)) },
                     Err(status) => Err(status),
                 }