crossbeam

One very common queue implementation you can use to implement actors is the crossbeam-deque. It's work-stealing in nature, works in multi-threaded environments and has no locks. The implementation is quite simple to follow: https://github.com/crossbeam-rs/crossbeam/blob/master/crossb...

Sure! However, the work-stealing queue in rayon [1] uses three atomic operations instead of the two atomic operations for a mutex for a global lock. The difference, however, is the three atomic operations for the thread-local queue should be uncontended, whereas a global lock on a global work queue would experience contention from every thread trying to access it for jobs. Between the choices of "single work sharing queue with a big mutex on it that all threads access for work" vs "per-thread work-stealing queue that's uncontended for the cost of one extra atomic," in what situations would the work-sharing queue with the global mutex outperform? Perhaps if there's a small number of jobs, and there's not enough time for the work-stealing algorithm to distribute jobs to the worker threads before the work-sharing algorithm has already finish

Crossbeam isn't async[0]. It can multiplex with itself (via the `select!` macro), but not with anything else. [0]: https://github.com/crossbeam-rs/crossbeam/issues/896

Why use this or Flume over the crossbeam multi-producer multi-consumer channel [1]? I thought crossbeam was well-regarded and pretty much the unofficial standard library for this sort of thing. https://github.com/crossbeam-rs/crossbeam/tree/master/crossb...

Undefined behavior on rust isn’t anything new, there’s even a section in the book about it. https://doc.rust-lang.org/beta/reference/behavior-considered... The issue referenced happens in an unsafe code block, see this patch. https://github.com/crossbeam-rs/crossbeam/pull/533/commits/b... There is no promise that Rust protects programmers from making mistakes in code marked as unsafe.

Reference counting [1] and atomic reference counting [2] are supported within Rust, and are sufficient for any persistent data structure without cycles. There's also a prototype crate for a mark and sweep GC [3], which would likely work for anything else. Writing such data structures using these features might be a bit more tedious than writing them in a GC language, but I suspect the increased explicitness provides a worthwhile tradeoff. See the crossbeam library [4] for some examples of lockless concurrent data structures implemented in Rust. [1] https://doc.rust-lang.org/std/rc/struct.Rc.html [2] https://doc.rust-lang.org/std/sync/struct.Arc.html [3] https://manishearth.github.io/blog/2016/08/18/gc-support-in-... [4] https://github.com/crossbeam-rs/crossbeam

> So why do have to manually mutex or semaphore your threads? This is not a type system with concurrency capabilities is meant for. You don't have to use mutex ! The Rust type system has two traits to ensure thread-safety : Send and Sync, and you can safely use anything which implement those traits. Mutex is one easy way to have these capabilities, but it's not the only one. You can build your own thread-safe data structure if you want, or even use third-party ones like crossbeam[1]. The compiler will then ensure that you never use non-thread-safe objects accross threads. > At least parrot and pony do away without that nonsense. What is parrot ? I've read about pony but not parrot, and Google isn't helping. [1] : https://github.com/crossbeam-rs/crossbeam/blob/master/README...