Am 13.04.2024 um 21:26 schrieb Chris M. Thomasson:

> On 4/12/2024 6:00 PM, Bonita Montero wrote:

>> There's no slow path with futexes since you've to notify _always_.

> Huh? Nope! Where did you get that idea from? calling notify is a slow
> path, and calling wait is a slow path.

Unlocking a futex always involves a notify since the notify doesn't
depend on a state like a wait().

>
>> And 1.7ns isn't slow.
>
> You do not want to _always_ call notify and/or wait when you do not have
> to.

You don't unterstand futexes. Show me your mutex basing on C++20 futexes.

On 4/13/2024 9:19 PM, Bonita Montero wrote:
> Am 13.04.2024 um 21:26 schrieb Chris M. Thomasson:
>
>> On 4/12/2024 6:00 PM, Bonita Montero wrote:
>
>>> There's no slow path with futexes since you've to notify _always_.
>
>> Huh? Nope! Where did you get that idea from? calling notify is a slow
>> path, and calling wait is a slow path.
>
> Unlocking a futex always involves a notify since the notify doesn't
> depend on a state like a wait().
>
>>
>>> And 1.7ns isn't slow.
>>
>> You do not want to _always_ call notify and/or wait when you do not
>> have to.
>
> You don't unterstand futexes. Show me your mutex basing on C++20 futexes.

Did you read it? using windwos futexes:

https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ

Notice how it does not unlock all the time?

I can port it to c++20.

Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:

> On 4/13/2024 9:19 PM, Bonita Montero wrote:

>> You don't unterstand futexes. Show me your mutex basing on C++20 futexes.
>
> Did you read it? using windwos futexes:
> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
> Notice how it does not unlock all the time?
> I can port it to c++20.

Show me your mutex with a futex.
It's impossible to write that without notifying *always*.

Am 14.04.2024 um 06:30 schrieb Bonita Montero:
> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>
>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>
>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>> futexes.
>>
>> Did you read it? using windwos futexes:
>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>> Notice how it does not unlock all the time?
>> I can port it to c++20.
>
> Show me your mutex with a futex.
> It's impossible to write that without notifying *always*.

That's the simplest code in C++20:

struct fute_xchg_mutex
{ fute_xchg_mutex();
void lock();
void unlock();
private:
atomic_bool m_locked;
};

fute_xchg_mutex::fute_xchg_mutex() :
m_locked( false )
{ }

void fute_xchg_mutex::lock()
{ while( m_locked.exchange( true, memory_order_acquire ) )
m_locked.wait( true, memory_order_relaxed );
}

void fute_xchg_mutex::unlock()
{ m_locked.store( false, memory_order_release );
m_locked.notify_one();
}

On 4/13/2024 9:30 PM, Bonita Montero wrote:
> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>
>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>
>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>> futexes.
>>
>> Did you read it? using windwos futexes:
>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>> Notice how it does not unlock all the time?
>> I can port it to c++20.
>
> Show me your mutex with a futex.
> It's impossible to write that without notifying *always*.

I beg to disagree.

On 4/13/2024 9:34 PM, Bonita Montero wrote:
> Am 14.04.2024 um 06:30 schrieb Bonita Montero:
>> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>>
>>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>>
>>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>>> futexes.
>>>
>>> Did you read it? using windwos futexes:
>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>> Notice how it does not unlock all the time?
>>> I can port it to c++20.
>>
>> Show me your mutex with a futex.
>> It's impossible to write that without notifying *always*.
>
> That's the simplest code in C++20:
>
> struct fute_xchg_mutex
> {
>     fute_xchg_mutex();
>     void lock();
>     void unlock();
> private:
>     atomic_bool m_locked;
> };
>
> fute_xchg_mutex::fute_xchg_mutex() :
>     m_locked( false )
> {
> }
>
> void fute_xchg_mutex::lock()
> {
>     while( m_locked.exchange( true, memory_order_acquire ) )
>         m_locked.wait( true, memory_order_relaxed );
> }
>
> void fute_xchg_mutex::unlock()
> {
>     m_locked.store( false, memory_order_release );
>     m_locked.notify_one();
^^^^^^^^^^

NONONNOONONO!

> }
>
>

On 4/13/2024 9:30 PM, Bonita Montero wrote:
> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>
>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>
>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>> futexes.
>>
>> Did you read it? using windwos futexes:
>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>> Notice how it does not unlock all the time?
>> I can port it to c++20.
>
> Show me your mutex with a futex.
> It's impossible to write that without notifying *always*.

this is a complete troll, right?

Am 14.04.2024 um 07:22 schrieb Chris M. Thomasson:
> On 4/13/2024 9:30 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>>
>>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>>
>>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>>> futexes.
>>>
>>> Did you read it? using windwos futexes:
>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>> Notice how it does not unlock all the time?
>>> I can port it to c++20.
>>
>> Show me your mutex with a futex.
>> It's impossible to write that without notifying *always*.
>
> this is a complete troll, right?

You don't know futexes.
Show me your code with a mutex basing on a futex.

On 4/13/2024 10:30 PM, Bonita Montero wrote:
> Am 14.04.2024 um 07:22 schrieb Chris M. Thomasson:
>> On 4/13/2024 9:30 PM, Bonita Montero wrote:
>>> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>>>
>>>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>>>
>>>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>>>> futexes.
>>>>
>>>> Did you read it? using windwos futexes:
>>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>> Notice how it does not unlock all the time?
>>>> I can port it to c++20.
>>>
>>> Show me your mutex with a futex.
>>> It's impossible to write that without notifying *always*.
>>
>> this is a complete troll, right?
>
> You don't know futexes.
> Show me your code with a mutex basing on a futex.
>

I did. Read again, well Windows Futex:

https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ

Do you really want me to port this to c++20?

Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
> On 4/13/2024 10:30 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 07:22 schrieb Chris M. Thomasson:
>>> On 4/13/2024 9:30 PM, Bonita Montero wrote:
>>>> Am 14.04.2024 um 06:26 schrieb Chris M. Thomasson:
>>>>
>>>>> On 4/13/2024 9:19 PM, Bonita Montero wrote:
>>>>
>>>>>> You don't unterstand futexes. Show me your mutex basing on C++20
>>>>>> futexes.
>>>>>
>>>>> Did you read it? using windwos futexes:
>>>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>>> Notice how it does not unlock all the time?
>>>>> I can port it to c++20.
>>>>
>>>> Show me your mutex with a futex.
>>>> It's impossible to write that without notifying *always*.
>>>
>>> this is a complete troll, right?
>>
>> You don't know futexes.
>> Show me your code with a mutex basing on a futex.
>>
>
> I did. Read again, well Windows Futex:
>
> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>
> Do you really want me to port this to c++20?

Show it here with correct formatting.

On 4/13/2024 10:36 PM, Bonita Montero wrote:
> Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
[...]
>> I did. Read again, well Windows Futex:
>>
>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>
>> Do you really want me to port this to c++20?
>
> Show it here with correct formatting.
>

Do you mean, indentation? ;^)

Anyway, you commented in the thread I linked you to.

So, you can read my code, right?

Am 14.04.2024 um 07:42 schrieb Chris M. Thomasson:
> On 4/13/2024 10:36 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
> [...]
>>> I did. Read again, well Windows Futex:
>>>
>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>
>>> Do you really want me to port this to c++20?
>>
>> Show it here with correct formatting.
>>
>
> Do you mean, indentation? ;^)
>
> Anyway, you commented in the thread I linked you to.
>
> So, you can read my code, right?

You don't understand futexes since you call notifying with
the slow path slow. But notifying is even not slow if there
are contenders with futexes.

On 4/13/2024 10:42 PM, Chris M. Thomasson wrote:
> On 4/13/2024 10:36 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
> [...]
>>> I did. Read again, well Windows Futex:
>>>
>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>
>>> Do you really want me to port this to c++20?
>>
>> Show it here with correct formatting.
>>
>
> Do you mean, indentation? ;^)
>
> Anyway, you commented in the thread I linked you to.
>
> So, you can read my code, right?

I use the explicit Windows API for a futex. Think of:

https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitonaddress

;^)

On 4/13/2024 10:46 PM, Bonita Montero wrote:
> Am 14.04.2024 um 07:42 schrieb Chris M. Thomasson:
>> On 4/13/2024 10:36 PM, Bonita Montero wrote:
>>> Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
>> [...]
>>>> I did. Read again, well Windows Futex:
>>>>
>>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>>
>>>> Do you really want me to port this to c++20?
>>>
>>> Show it here with correct formatting.
>>>
>>
>> Do you mean, indentation? ;^)
>>
>> Anyway, you commented in the thread I linked you to.
>>
>> So, you can read my code, right?
>
> You don't understand futexes since you call notifying with
> the slow path slow. But notifying is even not slow if there
> are contenders with futexes.

What? I am quite sure you read this right?
____________________
void unlock()
{ if (InterlockedExchange(&m_state, 0) == 2)
{
WakeByAddressSingle(&m_state);
}
} ____________________

Take careful notice how I try to avoid a call into WakeByAddressSingle?
See? ;^o

Am 14.04.2024 um 07:48 schrieb Chris M. Thomasson:
> On 4/13/2024 10:46 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 07:42 schrieb Chris M. Thomasson:
>>> On 4/13/2024 10:36 PM, Bonita Montero wrote:
>>>> Am 14.04.2024 um 07:32 schrieb Chris M. Thomasson:
>>> [...]
>>>>> I did. Read again, well Windows Futex:
>>>>>
>>>>> https://groups.google.com/g/comp.lang.c++/c/1MZvhswJ6DQ/m/qyaYH-i0CgAJ
>>>>>
>>>>> Do you really want me to port this to c++20?
>>>>
>>>> Show it here with correct formatting.
>>>>
>>>
>>> Do you mean, indentation? ;^)
>>>
>>> Anyway, you commented in the thread I linked you to.
>>>
>>> So, you can read my code, right?
>>
>> You don't understand futexes since you call notifying with
>> the slow path slow. But notifying is even not slow if there
>> are contenders with futexes.
>
> What? I am quite sure you read this right?
> ____________________
> void unlock()
> {
>     if (InterlockedExchange(&m_state, 0) == 2)
>     {
>         WakeByAddressSingle(&m_state);
>     }
> }
> ____________________
>
> Take careful notice how I try to avoid a call into WakeByAddressSingle?
> See? ;^o
>

This is from a benchmark of two constantly contending threads:

atomic with locker counter + std::binary_semaphore:
10.4597
atoomic with locker counter + shown futephore:
14.9949
Chris Code:
18.6445
shown atomic_bool with always wakeup:
24.7084
std::mutex:
33.8646

The numbers are in nanoseconds for a locking unlocking iteration.

That's my code:

#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>
#include <semaphore>
#include <algorithm>
#include <vector>

using namespace std;
using namespace chrono;

int main()
{ using kv = pair<char const *, double>;
vector<kv> results;
auto bench = [&]( char const *what, auto fn )
{
constexpr size_t ROUNDS = 10'000'000;
atomic_int64_t tSum = 0;
auto thr = [&]()
{
auto start = high_resolution_clock::now();
for( size_t r = ROUNDS; r; --r )
fn();
tSum.fetch_add( duration_cast<nanoseconds>(
high_resolution_clock::now() - start ).count() );
};
jthread jtA( thr ), jtB( thr );
jtA.join(), jtB.join();
results.emplace_back( what, tSum / ((double)ROUNDS * 2.0) );
};
// atomic coutner with futex-semaphore
atomic_uint32_t
lockCounter( 0 ),
futSem( 0 );
bench( "atomic coutner with futex-semaphore", [&]
{
if( lockCounter.fetch_add( 1, memory_order_acquire ) > 0 )
for( uint32_t before = futSem.load(
memory_order_relaxed ); ; )
if( !before )
futSem.wait( 0, memory_order_relaxed ),
before = futSem.load( memory_order_relaxed );
else if( futSem.compare_exchange_strong( before,
before - 1, memory_order_acquire, memory_order_relaxed ) ) [[likely]]
break;
if( lockCounter.fetch_sub( 1, memory_order_relaxed ) > 1 )
for( uint32_t before = futSem.load(
memory_order_relaxed ); ; )
if( futSem.compare_exchange_strong( before, before
+ 1, memory_order_release, memory_order_relaxed ) )
{
futSem.notify_one();
break;
}
} );
// std::mutex
mutex mtx;
bench( "std::mutex", [&] { mtx.lock(), mtx.unlock(); });
// atomic coutner with a binary_semaphore
binary_semaphore sem( 0 );
bench( "atomic coutner with binary_semaphore", [&]
{
if( lockCounter.fetch_add( 1, memory_order_acquire ) > 0 )
sem.acquire();
if( lockCounter.fetch_sub( 1, memory_order_release ) > 1 )
sem.release();
} );
// xchg-mutex and always wakeup
atomic_bool lockFlag( false );
bench( "xchg-mutex and always wakeup", [&]
{
while( lockFlag.exchange( true, memory_order_acquire ) )
lockFlag.wait( true, memory_order_relaxed );
lockFlag.store( false, memory_order_release );
lockFlag.notify_one();
} );
// Chris' mutex
atomic_int lockState( 0 );
bench( "Chris' mutex", [&]
{
if( lockState.exchange( 1, memory_order_acquire ) )
while( lockState.exchange( 2, memory_order_acquire ) )
lockState.wait( 2, memory_order_acquire );
if( lockState.exchange( 0, memory_order_release ) == 2 )
lockState.notify_one();
} );
sort( results.begin(), results.end(), []( kv &lhs, kv &rhs ) {
return lhs.second < rhs.second; } );
for( kv &result : results )
cout << result.first << ": " << result.second << endl;
}

On 4/14/2024 6:12 AM, Bonita Montero wrote:
> That's my code:
[...]

Might as well throw my semaphore into the mix:

https://vorbrodt.blog/2019/02/05/fast-semaphore/

I will code up a little program, most likely today, to check out those
neat C++20 futexes.

On 4/14/2024 12:02 PM, Chris M. Thomasson wrote:
> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>> That's my code:
> [...]
>
> Might as well throw my semaphore into the mix:

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Error! It's not my semaphore!

> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>
> I will code up a little program, most likely today, to check out those
> neat C++20 futexes.
>

OOPS! I misstated, I did not create this algo. Afaict, the original can
be found here:

https://www.haiku-os.org/legacy-docs/benewsletter/Issue1-26.html

Sorry everybody. Now, here is _my_ rwlock:

https://vorbrodt.blog/2019/02/14/read-write-mutex

All me! :^)

On 4/14/2024 6:12 AM, Bonita Montero wrote:
> That's my code:
>
[...]
>     atomic_int lockState( 0 );
>     bench( "Chris' mutex", [&]
>         {
>             if( lockState.exchange( 1, memory_order_acquire ) )
>                 while( lockState.exchange( 2, memory_order_acquire ) )

>                     lockState.wait( 2, memory_order_acquire );

No need for memory_order_acquire on the wait. Relaxed will do.

>             if( lockState.exchange( 0, memory_order_release ) == 2 )
>                 lockState.notify_one();
>         } );
>     sort( results.begin(), results.end(), []( kv &lhs, kv &rhs ) {
> return lhs.second < rhs.second; } );
>     for( kv &result : results )
>         cout << result.first << ": " << result.second << endl;
> }

Am 14.04.2024 um 21:02 schrieb Chris M. Thomasson:
> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>> That's my code:
> [...]
>
> Might as well throw my semaphore into the mix:
>
> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>
> I will code up a little program, most likely today, to check out those
> neat C++20 futexes.
>

A semaphore with a mutex, you're funny ...
That ain't fast.

On 4/14/2024 1:57 PM, Bonita Montero wrote:
> Am 14.04.2024 um 21:02 schrieb Chris M. Thomasson:
>> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>>> That's my code:
>> [...]
>>
>> Might as well throw my semaphore into the mix:
>>
>> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>>
>> I will code up a little program, most likely today, to check out those
>> neat C++20 futexes.
>>
>
> A semaphore with a mutex, you're funny ...
> That ain't fast.

The fast_semaphore::semaphore is meant to be a kernel semaphore. So, a
Windows one will work. A Linux one will work, and the portable mutex
condvar semaphore impl emulation will work. This semaphore is fast wrt
its fast paths. Btw, you have heard of the benaphore before, right?

https://www.haiku-os.org/legacy-docs/benewsletter/Issue1-26.html#Engineering1-26

Its been there for a while... ;^) It's something that every threading
nerd should know about. Remember when you called me a nerd several times
in the past? lol. ;^)

Anyway, take a close look at the fast paths vs the slow paths:

https://pastebin.com/raw/Q7p6e7Xc

_________________
class fast_semaphore
{ public:
fast_semaphore(int count) noexcept
: m_count(count), m_semaphore(0) {}

void post()
{
std::atomic_thread_fence(std::memory_order_release);
int count = m_count.fetch_add(1, std::memory_order_relaxed);
if (count < 0)
m_semaphore.post();
}

void wait()
{
int count = m_count.fetch_sub(1, std::memory_order_relaxed);
if (count < 1)
m_semaphore.wait();
std::atomic_thread_fence(std::memory_order_acquire);
}

private:
std::atomic<int> m_count;
semaphore m_semaphore;
};
_________________

On 4/14/2024 8:23 PM, Chris M. Thomasson wrote:
> On 4/14/2024 1:57 PM, Bonita Montero wrote:
>> Am 14.04.2024 um 21:02 schrieb Chris M. Thomasson:
>>> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>>>> That's my code:
>>> [...]
>>>
>>> Might as well throw my semaphore into the mix:
>>>
>>> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>>>
>>> I will code up a little program, most likely today, to check out
>>> those neat C++20 futexes.
>>>
>>
>> A semaphore with a mutex, you're funny ...
>> That ain't fast.
[...]

I think you might have a problem differentiating a fast-path from a
slow-path... Humm...

Am 15.04.2024 um 05:26 schrieb Chris M. Thomasson:
> On 4/14/2024 8:23 PM, Chris M. Thomasson wrote:
>> On 4/14/2024 1:57 PM, Bonita Montero wrote:
>>> Am 14.04.2024 um 21:02 schrieb Chris M. Thomasson:
>>>> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>>>>> That's my code:
>>>> [...]
>>>>
>>>> Might as well throw my semaphore into the mix:
>>>>
>>>> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>>>>
>>>> I will code up a little program, most likely today, to check out
>>>> those neat C++20 futexes.
>>>>
>>>
>>> A semaphore with a mutex, you're funny ...
>>> That ain't fast.
> [...]
>
> I think you might have a problem differentiating a fast-path from a
> slow-path... Humm...
>

Absolutely not, but you consider a futex wake as slow.

On 4/14/2024 9:15 PM, Bonita Montero wrote:
> Am 15.04.2024 um 05:26 schrieb Chris M. Thomasson:
>> On 4/14/2024 8:23 PM, Chris M. Thomasson wrote:
>>> On 4/14/2024 1:57 PM, Bonita Montero wrote:
>>>> Am 14.04.2024 um 21:02 schrieb Chris M. Thomasson:
>>>>> On 4/14/2024 6:12 AM, Bonita Montero wrote:
>>>>>> That's my code:
>>>>> [...]
>>>>>
>>>>> Might as well throw my semaphore into the mix:
>>>>>
>>>>> https://vorbrodt.blog/2019/02/05/fast-semaphore/
>>>>>
>>>>> I will code up a little program, most likely today, to check out
>>>>> those neat C++20 futexes.
>>>>>
>>>>
>>>> A semaphore with a mutex, you're funny ...
>>>> That ain't fast.
>> [...]
>>
>> I think you might have a problem differentiating a fast-path from a
>> slow-path... Humm...
>>
>
> Absolutely not, but you consider a futex wake as slow.
>

Yes. I consider a futex notify and wake as "slow" paths. One should
strive to avoid them. I don't know about the current impl of futex wrt
Linux and Windows. I just treat them as kernel calls that should be on
the slow path. Not on the fast path. The damn thing might even lock an
internal hashed mutex on the address for all I know wrt an unknown impl
of a futex.

Am 15.04.2024 um 07:03 schrieb Chris M. Thomasson:

> On 4/14/2024 9:15 PM, Bonita Montero wrote:

>> Absolutely not, but you consider a futex wake as slow.

> Yes. I consider a futex notify and wake as "slow" paths.

I've mentioned that a futex wake with no contenders is 1.7ns or about
10 clock cycles on my Zen4-CPU; that's nothing worth to think about.