Moving beyond Arc˂Mutex˂T˃˃ - Katharina Fey

Rust enforces unique lifetime and access bounds to data inside a program and thus impacts how memory must be managed. This is especially relevant for multi-threaded systems or applications where multiple parts may want to access some congested data. In this talk, I will cover some data synchronisation theory in Rust, starting at the common Arc˂Mutex˂T˃˃ pattern, and ending in an exploration of smart pointers and lock-free data structure design.

[@brunozimmermann8017]

Lockfree crate's author here. I would like to just point out two things:
1. Lockfree crate's biggest drawback is not replacing the global, blocking allocator by a non-blocking one (that is a feature I ended up never implementing);
2. Lockfree crate's performance is actually... worse than some of the blocking counterparts in all benchmarks I have written, and so, I would not advise one to use lockfree seeking performance, but rather seeking properties such as being reliable, free from deadlocks, etc.

[@mikkelens]

I did not expect to actually understand the practical use and abstracted hardware concepts of Atomics when I started watching this talk, but I am very happy with this outcome!

[@YannSimon]

I said "consensus" in front of my screen, and you heard it! Crazy technology with space-time travels.

[@samuelsquire4035]

Thank you for this talk. In my experience, memory latency is so high that mutexed access to data is a bottleneck. Instead, I shard my data between threads and each thread handles a subset of requests. This can give you embarassingly parallel performance due to the single threaded nature of each shard.

[@oleksrow]

Nice deep dive!❤

[@SquirrltheRiddl]

greaaaaat talk! thx

[@arubaga]

At 34:08 it should be // unlock the mutex