https://github.com/kixunil/linux_once

A Linux-optimized drop-in replacement for `std::sync::Once`
https://github.com/kixunil/linux_once

Last synced: 3 months ago
JSON representation

A Linux-optimized drop-in replacement for `std::sync::Once`

• Host: GitHub
• URL: https://github.com/kixunil/linux_once
• Owner: Kixunil
• Created: 2021-02-04T23:24:20.000Z (almost 4 years ago)
• Default Branch: master
• Last Pushed: 2021-02-06T22:08:30.000Z (almost 4 years ago)
• Last Synced: 2023-12-08T15:34:48.931Z (about 1 year ago)
• Language: Rust
• Size: 6.84 KB
• Stars: 4
• Watchers: 3
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Linux Once

A Linux-optimized drop-in replacement for `std::sync::Once`

This crate implements the same thing as `std::sync::Once` except it internally uses Linux `futex`

instead of `CondVar`. This leads to ridiculously simple code (compared to `std`) with no

`unsafe` and theoretically a bit better performance. (Sadly, in practice the performance is

roughly same.)

On non-Linux systems this crate just reexports `Once` from `std` so that you can

unconditionally import `Once` from this crate and it'll work just fine.

This crate can reach 1.0 very soon. Things to resolve before then:

* wait for stabilization of force call?

## Why this should have better performance, yet it doesn't?

`Once` in std is also implemented using atomics but waiters use `thread::park` for waiting.

This happens to also be implemented using futex on Linux but with one difference: each waiting

thread has its own futex. The Thread handles are sotred in an atomic linked list (really clever

stuff) and the list is iterated when closure finishes execution waking the threads on-by-one,

issuing syscall for each thread.

This crate uses a single futex and a single syscall to wake up all waiters.

Here's where performance difference should be: one syscall should be less expensive than

multiple syscalls.

So why is this not faster then?

Frankly, I have no idea. I guess there might be some crazy optimization that makes `futex`

syscalls magically less expensive or maybe syscalls are nowhere near as expensive as I

originaly thought. These are my speculations. If you happen to have more information, please

let me know.

## License

MITNFA