crossbeam-rs/crossbeam

This system is a Rust library providing a suite of concurrent programming primitives, including lock-free channels, work-stealing deques, epoch-based memory reclamation, and various queue and synchronization utilities. It offers thread-safe data structures like skip lists and atomic cells, designed for high-performance multi-threaded applications with support for no\_std environments. The codebase emphasizes memory safety and correctness through extensive testing, including sanitizer checks and model checking, while maintaining a modular architecture across multiple sub-crates.

29 changes.

This period focused on consolidating the Crossbeam ecosystem into a unified workspace, establishing rigorous CI and linting standards, and updating dependencies to the Rust 2021 edition. It involved the initial release and stabilization of key subcrates like crossbeam-deque, crossbeam-epoch, and crossbeam-skiplist, alongside significant internal refactoring and new synchronization primitives in crossbeam-utils and crossbeam-channel.

6 changes.

This period focused on the introduction of the crossbeam-queue crate, providing ArrayQueue and SegQueue implementations with comprehensive test coverage for concurrent access patterns. It also established a robust testing infrastructure by adding microbenchmarks for crossbeam-channel and loom-based concurrency tests for epoch primitives. Additionally, an automated release publishing script was implemented to streamline the distribution workflow for the project's crates.

This change introduces new internal synchronization primitives to the crossbeam-epoch crate: a lock-free intrusive linked list (\list.rs\) and a Michael-Scott lock-free queue (\queue.rs\). These components provide the foundational data structures used by the epoch-based reclamation system to manage memory safely across threads without locks. The list supports intrusive elements and deferred destruction via the epoch guard, while the queue offers efficient push/pop operations with cache-padded head/tail pointers to reduce false sharing.

crossbeam-epoch/src/sync · high confidence

Added three new example programs demonstrating crossbeam-channel usage: fibonacci.rs shows an asynchronous Fibonacci sequence generator using bounded channels; matching.rs illustrates concurrent send/receive operations on a shared channel using select!; and stopwatch.rs demonstrates handling SIGINT signals with a bounded channel and select! for periodic updates.

crossbeam-channel/examples · high confidence

A new example file, sanitize.rs, has been added to the examples directory. This example demonstrates a multi-threaded workload using crossbeam-epoch's atomic operations and garbage collection, utilizing the fastrand library for random number generation to simulate various access patterns and timing scenarios.

crossbeam-epoch/examples · high confidence

A new shell script (tools/publish.sh) has been added to streamline the release process. This tool allows users to publish a new release for a specified crate and version by handling git tagging, branch validation, and invoking 'cargo publish' with the stable toolchain, ensuring a consistent and error-checked workflow.

tools · high confidence

The \crossbeam-epoch\ crate now provides a complete epoch-based garbage collection system for safe memory reclamation in concurrent data structures. This includes the \Collector\ and \LocalHandle\ APIs for managing garbage collection lifecycles, \Guard\ for pinning threads to prevent premature deallocation, and \Atomic\/\Owned\ types for lock-free pointer operations. The implementation supports deferred destruction of objects, including dynamically sized types, and is designed to be compatible with sanitizers like ThreadSanitizer and Miri.

crossbeam-epoch/src · high confidence

This entry introduces the crossbeam crate as a new dependency for concurrent programming in Rust. It re-exports key components from its sub-crates, including \crossbeam-utils\ (for \AtomicCell\, \CachePadded\, and \Backoff\), \crossbeam-channel\ (for MPMC channels and select), \crossbeam-deque\ (for work-stealing deques), \crossbeam-epoch\ (for epoch-based garbage collection), and \crossbeam-queue\ (for bounded and unbounded queues). The crate supports \no\_std\ environments and enables \std\ features conditionally.

src · high confidence

This entry introduces the crossbeam-deque crate, providing work-stealing deques primarily intended for building task schedulers. The initial release (v0.8.8) includes improved compatibility with ThreadSanitizer, achieved via a new build script that detects sanitization targets and emits the \crossbeam\_sanitize\_thread\ configuration flag. It also adds 64-bit index support on 32-bit platforms where 64-bit atomics are available, and establishes a Minimum Supported Rust Version (MSRV) policy of 1 year, currently set to Rust 1.74.

crossbeam-deque · high confidence

The crossbeam-skiplist crate is introduced, providing concurrent, thread-safe \SkipMap\ and \SkipSet\ data structures with an API similar to \BTreeMap\ and \BTreeSet\. This initial release (v0.1.0) includes the core implementation, documentation, and licensing files (MIT/Apache-2.0). It requires Rust 1.74+ and supports \no\_std\ environments when the \alloc\ feature is enabled.

crossbeam-skiplist · high confidence

The \crossbeam-queue\ crate is now available, providing two concurrent queue implementations: \ArrayQueue\, a bounded multi-producer multi-consumer queue that allocates a fixed-capacity buffer for faster performance, and \SegQueue\, an unbounded multi-producer multi-consumer queue that allocates segments on demand. Both queues support \no\_std\ environments (with the \alloc\ feature), implement \UnwindSafe\ and \RefUnwindSafe\, and utilize \MaybeUninit\ for safe memory management. The \ArrayQueue\ includes a \force\_push\ method to operate as a ring buffer when full, while \SegQueue\ uses a linked list of blocks for dynamic sizing.

crossbeam-queue/src · high confidence

Users can now provide a custom \Comparator\ implementation to \SkipMap\ and \SkipSet\ instead of relying on the default \Ord\ trait. This allows for flexible key ordering and equality logic, such as case-insensitive string comparisons or runtime-configurable rules, while maintaining the same concurrent, lock-free interface as the standard ordered maps.

crossbeam-skiplist/src · high confidence

crossbeam-utils now includes a new \Backoff\ utility for performing exponential backoff in spin loops, helping to reduce contention in lock-free code. Additionally, \CachePadded\ has been updated to use architecture-specific cache line alignments (such as 128 bytes on x86-64 and aarch64) and is now \\#\[repr(C)\]\ to ensure safe casting to and from the underlying type.

crossbeam-utils/src · high confidence

The benchmarks directory now includes a comprehensive suite for comparing crossbeam-channel against other Rust channel implementations (flume, futures-channel, mpsc, lockfree, atomicring, atomicringqueue, bus, crossbeam-deque, segqueue, mpmc) and Go channels. The suite covers single-producer-single-consumer, multi-producer-single-consumer, single-producer-multi-consumer, and multi-producer-multi-consumer scenarios with bounded and unbounded capacities, including select operations. Results are collected via run.sh and visualized using plot.py into a plot.png chart, with documentation provided in the new README.md.

crossbeam-channel/benchmarks · high confidence

The \crossbeam-utils\ crate now exposes a new \sync\ module containing three thread-synchronization primitives. \Parker\ provides a low-level thread parking mechanism with timeout and deadline support, allowing threads to block until unparked. \ShardedLock\ offers a sharded reader-writer lock that improves read concurrency by distributing locks across multiple shards, while \WaitGroup\ enables threads to synchronize the start or end of computations by waiting for all cloned references to be dropped.

crossbeam-utils/src/sync · high confidence

The repository has been initialized with the Crossbeam project, including the main crate and its subcrates (crossbeam-channel, crossbeam-deque, crossbeam-epoch, crossbeam-queue, crossbeam-utils). This change introduces standard project configuration files: a Clippy configuration that disallows unsafe \transmute\_copy\ and raw allocation functions in favor of safer helpers, a Rustfmt configuration enforcing specific import granularity and style editions, a ShellCheck configuration for shell scripts, and a Taplo configuration for TOML formatting. It also adds a comprehensive CHANGELOG documenting the project's history from v0.1 to v0.8.5, updates the README with current usage instructions and compatibility notes (Rust 1.74+), and establishes the dual MIT/Apache-2.0 licensing structure.

(repo-wide) · high confidence

The \crossbeam-deque\ crate now provides a concurrent work-stealing deque implementation, exposing \Worker\ (FIFO/LIFO), \Injector\, \Stealer\, and \Steal\ types. This enables efficient task scheduling in multi-threaded environments by allowing threads to push tasks to their local queues and steal batches from others, with support for batch stealing operations to reduce contention.

crossbeam-deque/src · high confidence

The \AtomicCell\ implementation in \crossbeam-utils\ has been refactored to use a stamped sequence lock (\SeqLock\ or \SeqLockWide\ for narrow architectures) as the fallback mechanism when native atomic instructions are unavailable. This change replaces the previous global lock approach, ensuring that aborted writes do not incorrectly update the sequence stamp, which prevents potential data races and improves correctness for non-lock-free types. Additionally, the module now exposes the \AtomicConsume\ trait, allowing efficient 'consume' ordering loads on architectures that support it (like ARM/AArch64) while falling back to 'acquire' ordering elsewhere.

crossbeam-utils/src/atomic · high confidence

This change introduces the CHANGELOG.md for crossbeam-channel version 0.5.17, documenting fixes for undefined behavior in bounded channels, behavior inconsistencies in the \at()\ method, overflow handling during channel initialization, and the adoption of 64-bit indices on 32-bit platforms where supported. It also updates the MSRV policy to support a 1-year window. Additionally, the repository now includes explicit LICENSE-APACHE, LICENSE-MIT, and LICENSE-THIRD-PARTY files to clarify the dual MIT/Apache-2.0 licensing and third-party attribution.

crossbeam-channel · high confidence

The crossbeam-channel crate has been restructured into distinct internal modules (channel, context, counter, err, select, select\_macro, utils, waker) to improve code organization and maintainability. This change introduces a non-poison Mutex wrapper for safer synchronization, implements a dedicated thread-local Context for select operations, and adds new error types (TryReadyError, ReadyTimeoutError) with Display and Error trait implementations. The refactoring also includes optimizations such as removing bounds checks in Waker::try\_select, discarding messages eagerly when the last receiver is dropped, and handling overflow in bounded channel initialization. These changes enhance reliability and performance without altering the public API surface.

crossbeam-channel/src · high confidence

The crossbeam-epoch crate now includes better compatibility with ThreadSanitizer by detecting sanitization builds via the build script and adjusting internal behavior accordingly. Additionally, the minimum supported Rust version (MSRV) policy has been updated to support releases going back at least one year, aligning with rayon's MSRV policy, and the current MSRV is set to Rust 1.74.

crossbeam-epoch · high confidence

The CI infrastructure now includes dedicated shell scripts to run a broader suite of checks: \test.sh\ for standard and cross-compilation tests, \careful.sh\ for undefined behavior detection with \cargo-careful\, \miri.sh\ for Miri-based memory safety verification, \san.sh\ for Address, Memory, and Thread Sanitizers, \check-features.sh\ for exhaustive feature-combination validation (including MSRV and \no\_std\ targets), \dependencies.sh\ for dependency tree analysis, and \crossbeam-epoch-loom.sh\ for loom-based concurrency testing.

ci · high confidence

The internal channel implementation has been restructured into distinct, modular 'flavors' located in the \flavors\ module. This change introduces specific implementations for bounded channels (\array\), unbounded channels (\list\), and specialized channels for timed delivery (\at\), periodic ticks (\tick\), zero-capacity rendezvous (\zero\), and non-delivering channels (\never\). This modularization isolates the logic for each channel type, improving code organization and maintainability while preserving the existing public API behavior.

crossbeam-channel/src/flavors · high confidence

This change introduces the CHANGELOG.md for crossbeam-queue v0.3.14, documenting that the library now uses 64-bit indices on 32-bit platforms when 64-bit atomics are available and updates the Minimum Supported Rust Version (MSRV) policy to support releases for one year instead of six. It also adds the full text of the Apache-2.0 and MIT license files, reflecting the crate's dual licensing model.

crossbeam-queue · high confidence

This change introduces the changelog for crossbeam-utils v0.8.23, which fixes a safety violation when ShardedLockWriteGuard is leaked and improves compatibility with ThreadSanitizer. It also updates the MSRV policy to support a 1-year window. The diff includes the full historical changelog, license files, and a build script that detects thread sanitizers to force fallback implementations for AtomicCell, ensuring correctness under sanitization.

crossbeam-utils · high confidence

Add microbenchmarks for crossbeam-channel performance testing; Added benchmark suite and example for crossbeam-skiplist; Added benchmark suite for epoch operations; Added benchmarks for AtomicCell operations; Added comprehensive test coverage for deque primitives; Added comprehensive test suite for SkipList, SkipMap, and SkipSet; Added comprehensive test suites for crossbeam-utils components; Added loom-based concurrency tests for epoch primitives and Treiber stack; Added test coverage for ArrayQueue and SegQueue; Added tests for subcrate re-exports; Expanded test coverage for crossbeam-channel channel flavors and selection mechanisms.

The crossbeam workspace has been updated to version 0.8.5, migrating all subcrates (crossbeam-channel, crossbeam-deque, crossbeam-epoch, crossbeam-queue, crossbeam-skiplist, crossbeam-utils) to the Rust 2021 edition. The minimum supported Rust version (MSRV) for most crates is now 1.74, with crossbeam-queue requiring 1.60 and crossbeam-utils 1.56. Dependencies have been bumped to crossbeam-channel 0.5.17, crossbeam-deque 0.8.8, crossbeam-epoch 0.9.21, crossbeam-queue 0.3.14, crossbeam-skiplist 0.1.3, and crossbeam-utils 0.8.23. The workspace now uses resolver 2 and enforces strict linting via workspace-level lints configuration.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 73 → 74 (+1.0)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 89 → 89 (+0.0)
• Architecture 100 → 99 (-1.0)
• Maturity 61 → 61 (+0.1)
• Readiness 87 → 87 (+0.3)
• Security 75 → 81 (+6.3)

• Hotspot: crossbeam-deque/src/deque.rs (crossbeam-deque/src/deque.rs)
• Hotspot: crossbeam-skiplist/src/base.rs (crossbeam-skiplist/src/base.rs)
• Off-boarding risk: anonymized user #1

• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Inconsistent naming for blocking vs non-blocking operations. try_send is non-blocking, while send is blocking. However, the timeout variants are named send_timeout and send_deadline rather than send_with_timeout or similar, creating a slight lexical inconsistency between the base blocking call (send) and its timed variants. More critically, Receiver uses recv (blocking) and try_recv (non-blocking), which is consistent with Sender, but the timeout methods on Receiver are recv_timeout/recv_deadline. While consistent within the channel module, the mix of send/recv (blocking) and try_send/try_recv (non-blocking) is standard, but the lack of a unified send_with_timeout pattern makes the API surface feel slightly fragmented between 'try' and 'timeout' naming conventions.
• Inconsistent return types for equivalent operations in SkipList vs SkipMap. SkipList.get_or_insert returns RefEntry (which requires a guard to release), while SkipMap.get_or_insert returns Entry (which does not require a guard for release, as implied by the lack of guard parameter in Entry.remove() in SkipMap). This inconsistency forces users to handle lifetimes and guards differently for seemingly identical logical operations depending on whether they use the base SkipList or the typed SkipMap.
• Inconsistent verb usage for state management operations. register/unregister and watch/unwatch are used for managing operations, but try_select and accept are used for execution/consumption. The distinction between register and watch is not immediately obvious from the names alone without deep documentation, as both seem to associate an operation with the handle. Similarly, accept consumes a token, but unregister removes an operation. The verbs register, watch, accept, unregister, unwatch create a slightly confusing set of actions for what is essentially a lifecycle of an async operation.
• Inverted test pyramid
• Off the main sequence: crossbeam-utils
• Off-boarding risk: anonymized user #1

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

crossbeam-rs/crossbeam was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.