instance_id
stringclasses 3
values | hints_text
stringclasses 3
values | created_at
stringclasses 3
values | version
stringclasses 2
values | test_patch
stringclasses 3
values | issue_numbers
sequencelengths 1
1
| patch
stringclasses 3
values | repo
stringclasses 1
value | pull_number
int64 454
1.1k
| base_commit
stringclasses 3
values | problem_statement
stringclasses 3
values | environment_setup_commit
stringclasses 2
values | FAIL_TO_PASS
sequencelengths 1
1
| PASS_TO_PASS
sequencelengths 7
84
| FAIL_TO_FAIL
sequencelengths 0
1
| PASS_TO_FAIL
sequencelengths 0
0
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
crossbeam-rs__crossbeam-1101
|
Thanks for the report!
IIUC, insert reduces the refcount of the old value and then sets the new value, so if insert makes the refcount zero, a get that occurs between the time the refcount is reduced and the new value is set will return None because it sees a deleted value with a refcount of zero.
Do you have any plans to fix it
I consider it a bug that needs to be fixed, but I'm not sure if I will be able to work on a fix anytime soon.
It would be great if you or someone else could work on a fix.
|
2024-04-12T12:16:27Z
|
0.8
|
diff --git a/crossbeam-skiplist/tests/map.rs b/crossbeam-skiplist/tests/map.rs
--- a/crossbeam-skiplist/tests/map.rs
+++ b/crossbeam-skiplist/tests/map.rs
@@ -920,3 +920,24 @@ fn clear() {
assert!(s.is_empty());
assert_eq!(s.len(), 0);
}
+
+// https://github.com/crossbeam-rs/crossbeam/issues/1023
+#[test]
+fn concurrent_insert_get_same_key() {
+ use std::sync::Arc;
+ let map: Arc<SkipMap<u32, ()>> = Arc::new(SkipMap::new());
+ let len = 10_0000;
+ let key = 0;
+ map.insert(0, ());
+
+ let getter = map.clone();
+ let handle = std::thread::spawn(move || {
+ for _ in 0..len {
+ map.insert(0, ());
+ }
+ });
+ for _ in 0..len {
+ assert!(getter.get(&key).is_some());
+ }
+ handle.join().unwrap()
+}
diff --git a/crossbeam-skiplist/tests/set.rs b/crossbeam-skiplist/tests/set.rs
--- a/crossbeam-skiplist/tests/set.rs
+++ b/crossbeam-skiplist/tests/set.rs
@@ -692,3 +692,24 @@ fn clear() {
assert!(s.is_empty());
assert_eq!(s.len(), 0);
}
+
+// https://github.com/crossbeam-rs/crossbeam/issues/1023
+#[test]
+fn concurrent_insert_get_same_key() {
+ use std::sync::Arc;
+ let set: Arc<SkipSet<u32>> = Arc::new(SkipSet::new());
+ let len = 10_0000;
+ let key = 0;
+ set.insert(0);
+
+ let getter = set.clone();
+ let handle = std::thread::spawn(move || {
+ for _ in 0..len {
+ set.insert(0);
+ }
+ });
+ for _ in 0..len {
+ assert!(getter.get(&key).is_some());
+ }
+ handle.join().unwrap()
+}
|
[
"1023"
] |
diff --git a/crossbeam-skiplist/src/base.rs b/crossbeam-skiplist/src/base.rs
--- a/crossbeam-skiplist/src/base.rs
+++ b/crossbeam-skiplist/src/base.rs
@@ -871,33 +871,17 @@ where
// the lifetime of the guard.
let guard = &*(guard as *const _);
- let mut search;
- loop {
- // First try searching for the key.
- // Note that the `Ord` implementation for `K` may panic during the search.
- search = self.search_position(&key, guard);
-
- let r = match search.found {
- Some(r) => r,
- None => break,
- };
+ // First try searching for the key.
+ // Note that the `Ord` implementation for `K` may panic during the search.
+ let mut search = self.search_position(&key, guard);
+ if let Some(r) = search.found {
let replace = replace(&r.value);
- if replace {
- // If a node with the key was found and we should replace it, mark its tower
- // and then repeat the search.
- if r.mark_tower() {
- self.hot_data.len.fetch_sub(1, Ordering::Relaxed);
- }
- } else {
+ if !replace {
// If a node with the key was found and we're not going to replace it, let's
// try returning it as an entry.
if let Some(e) = RefEntry::try_acquire(self, r) {
return e;
}
-
- // If we couldn't increment the reference count, that means someone has just
- // now removed the node.
- break;
}
}
diff --git a/crossbeam-skiplist/src/base.rs b/crossbeam-skiplist/src/base.rs
--- a/crossbeam-skiplist/src/base.rs
+++ b/crossbeam-skiplist/src/base.rs
@@ -937,6 +921,12 @@ where
)
.is_ok()
{
+ // This node has been abandoned
+ if let Some(r) = search.found {
+ if r.mark_tower() {
+ self.hot_data.len.fetch_sub(1, Ordering::Relaxed);
+ }
+ }
break;
}
diff --git a/crossbeam-skiplist/src/base.rs b/crossbeam-skiplist/src/base.rs
--- a/crossbeam-skiplist/src/base.rs
+++ b/crossbeam-skiplist/src/base.rs
@@ -956,13 +946,7 @@ where
if let Some(r) = search.found {
let replace = replace(&r.value);
- if replace {
- // If a node with the key was found and we should replace it, mark its
- // tower and then repeat the search.
- if r.mark_tower() {
- self.hot_data.len.fetch_sub(1, Ordering::Relaxed);
- }
- } else {
+ if !replace {
// If a node with the key was found and we're not going to replace it,
// let's try returning it as an entry.
if let Some(e) = RefEntry::try_acquire(self, r) {
|
crossbeam-rs/crossbeam
| 1,101
|
9e8596105bc9a6b343918b6ad1c9656dc24dc4f9
|
crossbeam-skiplist bug
[dependencies]
crossbeam-skiplist = "0.1.1"
```rs
fn main() {
let map: Arc<SkipMap<u32, u32>> = Arc::new(SkipMap::new());
map.insert(1, 2);
let map1 = map.clone();
std::thread::spawn(move||{
let key = 1;
for _ in 0..10_0000 {
let len = map1.len();
if let Some(entry) = map1.get(&key) {
}else{
panic!("len={},key={}",len,key);
}
std::thread::sleep(Duration::from_millis(1));
}
});
for _ in 0..10_0000 {
map.insert(1, 2);
std::thread::sleep(Duration::from_millis(100));
}
}
```
output:
```
thread '<unnamed>' panicked at 'len=1,key=1', src\main.rs:21:17
stack backtrace:
```
|
9e8596105bc9a6b343918b6ad1c9656dc24dc4f9
|
[
"concurrent_insert_get_same_key"
] |
[
"clear",
"compare_insert_with_absent_key",
"compare_and_insert",
"entry_remove",
"entry_reposition",
"front_and_back",
"entry",
"get",
"get_next_prev",
"get_or_insert_with",
"get_or_insert_with_panic",
"get_or_insert",
"insert",
"into_iter",
"is_empty",
"insert_and_remove",
"iter",
"iter_range",
"iter_range2",
"len",
"lower_bound",
"ordered_iter",
"ordered_range",
"next_back_memory_leak",
"next_memory_leak",
"range_next_memory_leak",
"smoke",
"upper_bound",
"remove",
"concurrent_compare_and_insert",
"concurrent_insert",
"concurrent_remove",
"get_or_insert_with_parallel_run"
] |
[] |
[] |
crossbeam-rs__crossbeam-454
|
Ah, we are waiting for `cfg(target_has_atomic)` to be stabilized, I guess?
Honestly, I would just use those non-usize atomic types. Platforms on which they don't exist are niche anyway...
|
2019-12-18T15:22:35Z
|
0.7
|
diff --git a/crossbeam-utils/tests/atomic_cell.rs b/crossbeam-utils/tests/atomic_cell.rs
--- a/crossbeam-utils/tests/atomic_cell.rs
+++ b/crossbeam-utils/tests/atomic_cell.rs
@@ -9,20 +9,19 @@ use crossbeam_utils::atomic::AtomicCell;
fn is_lock_free() {
struct UsizeWrap(usize);
struct U8Wrap(bool);
+ struct I16Wrap(i16);
assert_eq!(AtomicCell::<usize>::is_lock_free(), true);
assert_eq!(AtomicCell::<isize>::is_lock_free(), true);
assert_eq!(AtomicCell::<UsizeWrap>::is_lock_free(), true);
- assert_eq!(AtomicCell::<u8>::is_lock_free(), cfg!(feature = "nightly"));
- assert_eq!(
- AtomicCell::<bool>::is_lock_free(),
- cfg!(feature = "nightly")
- );
- assert_eq!(
- AtomicCell::<U8Wrap>::is_lock_free(),
- cfg!(feature = "nightly")
- );
+ assert_eq!(AtomicCell::<u8>::is_lock_free(), cfg!(has_atomic_u8));
+ assert_eq!(AtomicCell::<bool>::is_lock_free(), cfg!(has_atomic_u8));
+ assert_eq!(AtomicCell::<U8Wrap>::is_lock_free(), cfg!(has_atomic_u8));
+
+ assert_eq!(AtomicCell::<I16Wrap>::is_lock_free(), cfg!(has_atomic_u16));
+
+ assert_eq!(AtomicCell::<u128>::is_lock_free(), cfg!(has_atomic_u128));
}
#[test]
|
[
"423"
] |
diff --git a/crossbeam-utils/build.rs b/crossbeam-utils/build.rs
--- a/crossbeam-utils/build.rs
+++ b/crossbeam-utils/build.rs
@@ -3,6 +3,12 @@ extern crate autocfg;
fn main() {
let cfg = autocfg::new();
if cfg.probe_rustc_version(1, 31) {
- println!("cargo:rustc-cfg=has_min_const_fn");
+ autocfg::emit("has_min_const_fn");
}
+
+ cfg.emit_type_cfg("core::sync::atomic::AtomicU8", "has_atomic_u8");
+ cfg.emit_type_cfg("core::sync::atomic::AtomicU16", "has_atomic_u16");
+ cfg.emit_type_cfg("core::sync::atomic::AtomicU32", "has_atomic_u32");
+ cfg.emit_type_cfg("core::sync::atomic::AtomicU64", "has_atomic_u64");
+ cfg.emit_type_cfg("core::sync::atomic::AtomicU128", "has_atomic_u128");
}
diff --git a/crossbeam-utils/src/atomic/atomic_cell.rs b/crossbeam-utils/src/atomic/atomic_cell.rs
--- a/crossbeam-utils/src/atomic/atomic_cell.rs
+++ b/crossbeam-utils/src/atomic/atomic_cell.rs
@@ -519,37 +519,28 @@ macro_rules! impl_arithmetic {
}
}
};
- ($t:ty, $size:tt, $atomic:ty, $example:tt) => {
- #[cfg(target_has_atomic = $size)]
- impl_arithmetic!($t, $atomic, $example);
- };
}
-cfg_if! {
- if #[cfg(feature = "nightly")] {
- impl_arithmetic!(u8, "8", atomic::AtomicU8, "let a = AtomicCell::new(7u8);");
- impl_arithmetic!(i8, "8", atomic::AtomicI8, "let a = AtomicCell::new(7i8);");
- impl_arithmetic!(u16, "16", atomic::AtomicU16, "let a = AtomicCell::new(7u16);");
- impl_arithmetic!(i16, "16", atomic::AtomicI16, "let a = AtomicCell::new(7i16);");
- impl_arithmetic!(u32, "32", atomic::AtomicU32, "let a = AtomicCell::new(7u32);");
- impl_arithmetic!(i32, "32", atomic::AtomicI32, "let a = AtomicCell::new(7i32);");
- impl_arithmetic!(u64, "64", atomic::AtomicU64, "let a = AtomicCell::new(7u64);");
- impl_arithmetic!(i64, "64", atomic::AtomicI64, "let a = AtomicCell::new(7i64);");
- impl_arithmetic!(u128, "let a = AtomicCell::new(7u128);");
- impl_arithmetic!(i128, "let a = AtomicCell::new(7i128);");
- } else {
- impl_arithmetic!(u8, "let a = AtomicCell::new(7u8);");
- impl_arithmetic!(i8, "let a = AtomicCell::new(7i8);");
- impl_arithmetic!(u16, "let a = AtomicCell::new(7u16);");
- impl_arithmetic!(i16, "let a = AtomicCell::new(7i16);");
- impl_arithmetic!(u32, "let a = AtomicCell::new(7u32);");
- impl_arithmetic!(i32, "let a = AtomicCell::new(7i32);");
- impl_arithmetic!(u64, "let a = AtomicCell::new(7u64);");
- impl_arithmetic!(i64, "let a = AtomicCell::new(7i64);");
- impl_arithmetic!(u128, "let a = AtomicCell::new(7u128);");
- impl_arithmetic!(i128, "let a = AtomicCell::new(7i128);");
- }
-}
+#[cfg(has_atomic_u8)]
+impl_arithmetic!(u8, atomic::AtomicU8, "let a = AtomicCell::new(7u8);");
+#[cfg(has_atomic_u8)]
+impl_arithmetic!(i8, atomic::AtomicI8, "let a = AtomicCell::new(7i8);");
+#[cfg(has_atomic_u16)]
+impl_arithmetic!(u16, atomic::AtomicU16, "let a = AtomicCell::new(7u16);");
+#[cfg(has_atomic_u16)]
+impl_arithmetic!(i16, atomic::AtomicI16, "let a = AtomicCell::new(7i16);");
+#[cfg(has_atomic_u32)]
+impl_arithmetic!(u32, atomic::AtomicU32, "let a = AtomicCell::new(7u32);");
+#[cfg(has_atomic_u32)]
+impl_arithmetic!(i32, atomic::AtomicI32, "let a = AtomicCell::new(7i32);");
+#[cfg(has_atomic_u64)]
+impl_arithmetic!(u64, atomic::AtomicU64, "let a = AtomicCell::new(7u64);");
+#[cfg(has_atomic_u64)]
+impl_arithmetic!(i64, atomic::AtomicI64, "let a = AtomicCell::new(7i64);");
+#[cfg(has_atomic_u128)]
+impl_arithmetic!(u128, atomic::AtomicU128, "let a = AtomicCell::new(7u128);");
+#[cfg(has_atomic_u128)]
+impl_arithmetic!(i128, atomic::AtomicI128, "let a = AtomicCell::new(7i128);");
impl_arithmetic!(
usize,
diff --git a/crossbeam-utils/src/atomic/atomic_cell.rs b/crossbeam-utils/src/atomic/atomic_cell.rs
--- a/crossbeam-utils/src/atomic/atomic_cell.rs
+++ b/crossbeam-utils/src/atomic/atomic_cell.rs
@@ -741,17 +732,14 @@ macro_rules! atomic {
atomic!(@check, $t, AtomicUnit, $a, $atomic_op);
atomic!(@check, $t, atomic::AtomicUsize, $a, $atomic_op);
- #[cfg(feature = "nightly")]
- {
- #[cfg(target_has_atomic = "8")]
- atomic!(@check, $t, atomic::AtomicU8, $a, $atomic_op);
- #[cfg(target_has_atomic = "16")]
- atomic!(@check, $t, atomic::AtomicU16, $a, $atomic_op);
- #[cfg(target_has_atomic = "32")]
- atomic!(@check, $t, atomic::AtomicU32, $a, $atomic_op);
- #[cfg(target_has_atomic = "64")]
- atomic!(@check, $t, atomic::AtomicU64, $a, $atomic_op);
- }
+ #[cfg(has_atomic_u8)]
+ atomic!(@check, $t, atomic::AtomicU8, $a, $atomic_op);
+ #[cfg(has_atomic_u16)]
+ atomic!(@check, $t, atomic::AtomicU16, $a, $atomic_op);
+ #[cfg(has_atomic_u32)]
+ atomic!(@check, $t, atomic::AtomicU32, $a, $atomic_op);
+ #[cfg(has_atomic_u64)]
+ atomic!(@check, $t, atomic::AtomicU64, $a, $atomic_op);
break $fallback_op;
}
|
crossbeam-rs/crossbeam
| 454
|
424f926673d652f306f266d4309ed8717e931144
|
AtomicCell without lock for non-usize values in stable.
Now that `std::atomic::AtomicU{8,16,32,64}` has been stabilized, please allow `AtomicCell` to store values with non-`usize` widths without a lock.
This would require increasing the min rust version. Let me know if you like me to send a pull request.
Thanks.
|
bfb7705989a0961a16386ae2109bc2ef7f0bbe5e
|
[
"is_lock_free"
] |
[
"const_atomic_cell_new",
"drops_u8",
"drops_unit",
"drops_usize",
"garbage_padding",
"modular_u8",
"modular_usize"
] |
[] |
[] |
crossbeam-rs__crossbeam-552
|
`Local::bag` field is 2056 bytes and already exceeds 2048 bytes, so there seems to be no other way to do this than reduce the size of `Bag`.
https://github.com/crossbeam-rs/crossbeam/blob/bfb7705989a0961a16386ae2109bc2ef7f0bbe5e/crossbeam-epoch/src/internal.rs#L362-L363
And to reduce the size of the `Bag`, it needs to reduce `MAX_OBJECTS`.
https://github.com/crossbeam-rs/crossbeam/blob/bfb7705989a0961a16386ae2109bc2ef7f0bbe5e/crossbeam-epoch/src/internal.rs#L56-L67
@stjepang: Is it okay to reduce `MAX_OBJECTS`? Or do you think we need to think of another way?
It should be totally fine to reduce it to 31 (if my calculation is right).
|
2020-09-01T08:37:42Z
|
0.7
|
diff --git a/crossbeam-epoch/src/internal.rs b/crossbeam-epoch/src/internal.rs
--- a/crossbeam-epoch/src/internal.rs
+++ b/crossbeam-epoch/src/internal.rs
@@ -374,6 +372,13 @@ pub struct Local {
pin_count: Cell<Wrapping<usize>>,
}
+// Make sure `Local` is less than or equal to 2048 bytes.
+// https://github.com/crossbeam-rs/crossbeam/issues/551
+#[test]
+fn local_size() {
+ assert_eq!(2040, core::mem::size_of::<Local>());
+}
+
impl Local {
/// Number of pinnings after which a participant will execute some deferred functions from the
/// global queue.
|
[
"551"
] |
diff --git a/crossbeam-epoch/src/internal.rs b/crossbeam-epoch/src/internal.rs
--- a/crossbeam-epoch/src/internal.rs
+++ b/crossbeam-epoch/src/internal.rs
@@ -55,7 +55,7 @@ use crate::sync::queue::Queue;
/// Maximum number of objects a bag can contain.
#[cfg(not(feature = "sanitize"))]
-const MAX_OBJECTS: usize = 64;
+const MAX_OBJECTS: usize = 62;
#[cfg(feature = "sanitize")]
const MAX_OBJECTS: usize = 4;
diff --git a/crossbeam-epoch/src/internal.rs b/crossbeam-epoch/src/internal.rs
--- a/crossbeam-epoch/src/internal.rs
+++ b/crossbeam-epoch/src/internal.rs
@@ -174,8 +174,6 @@ impl Default for Bag {
Deferred::new(no_op_func),
Deferred::new(no_op_func),
Deferred::new(no_op_func),
- Deferred::new(no_op_func),
- Deferred::new(no_op_func),
],
};
#[cfg(feature = "sanitize")]
|
crossbeam-rs/crossbeam
| 552
|
bfb7705989a0961a16386ae2109bc2ef7f0bbe5e
|
The Local structure is 2104 bytes long and jemalloc rounds this to 4096 bytes.
The Local structure here https://searchfox.org/mozilla-central/source/third_party/rust/crossbeam-epoch/src/internal.rs#287 is 2104 bytes long. When compiled into Firefox and using the jamalloc memory allocator this is rounded up to 4096 bytes (a very common practice). This wastes just under 12KB for a Firefox process that loads a simple website. It'd be nice if it could allocate 2048 bytes or less saving this memory.
Thanks.
|
bfb7705989a0961a16386ae2109bc2ef7f0bbe5e
|
[
"internal::local_size"
] |
[
"atomic::tests::valid_tag_i64",
"atomic::tests::valid_tag_i8",
"collector::tests::drop_array",
"collector::tests::flush_local_bag",
"collector::tests::garbage_buffering",
"collector::tests::pin_reentrant",
"deferred::tests::long_slice_usize",
"deferred::tests::boxed_slice_i32",
"deferred::tests::on_heap",
"default::tests::pin_while_exiting",
"deferred::tests::string",
"deferred::tests::on_stack",
"internal::tests::check_defer",
"internal::tests::check_bag",
"sync::list::tests::delete",
"sync::list::tests::insert",
"sync::queue::test::is_empty_dont_pop",
"sync::queue::test::push_pop_2",
"sync::queue::test::push_try_pop_1",
"sync::queue::test::push_try_pop_2",
"sync::queue::test::push_pop_1",
"sync::queue::test::push_pop_many_seq",
"sync::queue::test::push_try_pop_many_seq",
"collector::tests::buffering",
"collector::tests::destroy_array",
"sync::list::tests::iter_multi",
"sync::list::tests::insert_delete_multi",
"collector::tests::incremental",
"collector::tests::count_drops",
"collector::tests::count_destroy",
"collector::tests::stress",
"sync::queue::test::push_try_pop_many_mpmc",
"sync::queue::test::push_try_pop_many_spmc",
"sync::queue::test::push_try_pop_many_spsc",
"sync::queue::test::push_pop_many_spsc",
"collector::tests::pin_holds_advance",
"crossbeam-epoch/src/atomic.rs - atomic::Array (line 241)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::from (line 767)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::into_owned (line 659)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::compare_and_set (line 463)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::from (line 723)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::from (line 752)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::init (line 324)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::fetch_and (line 579)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::new (line 309)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::store (line 414)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::null (line 345)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::fetch_or (line 604)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::compare_and_set_weak (line 514)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::load_consume (line 394)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::init (line 891)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::from (line 1008)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::fetch_xor (line 629)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::into_shared (line 904)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::from_raw (line 844)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::tag (line 922)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::swap (line 436)",
"crossbeam-epoch/src/atomic.rs - atomic::Atomic<T>::load (line 368)",
"crossbeam-epoch/src/atomic.rs - atomic::Pointable (line 132)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::with_tag (line 937)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'_,T>::from (line 1343)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::new (line 876)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::into_owned (line 1275)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::as_ref (line 1241)",
"crossbeam-epoch/src/atomic.rs - atomic::Owned<T>::into_box (line 859)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::deref_mut (line 1194)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::deref (line 1161)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::null (line 1108)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::as_raw (line 1084)",
"crossbeam-epoch/src/collector.rs - collector::fmt (line 5)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::tag (line 1295)",
"crossbeam-epoch/src/guard.rs - guard::Guard (line 57)",
"crossbeam-epoch/src/guard.rs - guard::Guard (line 17)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::is_null (line 1125)",
"crossbeam-epoch/src/guard.rs - guard::Guard::collector (line 403)",
"crossbeam-epoch/src/guard.rs - guard::Guard::flush (line 288)",
"crossbeam-epoch/src/guard.rs - guard::Guard (line 32)",
"crossbeam-epoch/src/guard.rs - guard::Guard::defer_unchecked (line 161)",
"crossbeam-epoch/src/guard.rs - guard::unprotected (line 479)",
"crossbeam-epoch/src/atomic.rs - atomic::Shared<'g,T>::with_tag (line 1315)",
"crossbeam-epoch/src/guard.rs - guard::Guard::defer_unchecked (line 124)",
"crossbeam-epoch/src/guard.rs - guard::Guard::repin (line 316)",
"crossbeam-epoch/src/guard.rs - guard::Guard::defer_destroy (line 248)",
"crossbeam-epoch/src/guard.rs - guard::Guard::repin_after (line 352)"
] |
[
"crossbeam-epoch/src/guard.rs - guard::unprotected (line 449)"
] |
[] |
README.md exists but content is empty.
- Downloads last month
- 1