`Semaphore` cost O(waiters) time to wake up on, and quadratic in total about futures-intrusive

[Matthias247]

The behavior is now changed in master for all primitives that are part of the sync module

[Matthias247]

It's pretty easy to improve:

Before:

matthias@Matthiass-MBP  ~/Code/rust/futures-intrusive (test *)
$cargo run --example abc --release
    Finished release [optimized] target(s) in 0.09s
     Running `target/release/examples/abc`
Elapsed: 3361ms

After:

matthias@Matthiass-MBP  ~/Code/rust/futures-intrusive (test *)
$cargo run --example abc --release
   Compiling futures-intrusive v0.2.2 (/Users/matthias/Code/rust/futures-intrusive)
    Finished release [optimized] target(s) in 2.85s
     Running `target/release/examples/abc`
Elapsed: 138ms

Most wait lists in the library currently use a single linked list, which requires an O(n) iteration for some operations, but only requires to store a single pointer which minimizes the size of Futures. With the typical amount of tasks that interact with a wait list (which might be well below 100) that is not really an issue. But with your high numbers it certainly gets excessive slow.

Changing to a double linked list (which is a single line code change - since the list is already implemented) fixes the issue - at the cost of storing an additional pointer per Future. For Semaphore I'm definitely convinced that this seems to be the better tradeoff, since people would use it like you to let a big number of tasks wait on it, so let's make the change. For other things like Channels I'm still undecided.

It seems to be designed to wake the last waiter. But why it is still required even when !is_fair?

The idea here certainly was that the cost difference between waking the last or the first waiter isn't that high. And that waking the oldest waiter at least retains some amount of fairness.