Re: signalling a condvar from inside vs. signalling a condvar von outside

Now I wrote a little program to test if there's thundering herd problem
with glibc's mutex / condvar. This it is:
 #include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <semaphore>
#include <vector>
#include <sys/resource.h>
 using namespace std;
 int main()
{
     constexpr size_t N = 10'000;
     int nClients = thread::hardware_concurrency() - 1;
     mutex mtx;
     int signalled = 0;
     condition_variable cv;
     atomic_int ai( 0 );
     binary_semaphore bs( false );
     vector<jthread> clients;
     atomic_int64_t nVoluntary( 0 );
     for( int c = nClients; c; --c )
         clients.emplace_back( [&]
             {
                 for( size_t r = N; r; --r )
                 {
                     unique_lock lock( mtx );
                     cv.wait( lock, [&] { return (bool)signalled; } );
                     --signalled;
                     lock.unlock();
                     if( ai.fetch_sub( 1, memory_order_relaxed ) == 1 )
                         bs.release( 1 );
                 }
                 rusage ru;
                 getrusage( RUSAGE_THREAD, &ru );
                 nVoluntary.fetch_add( ru.ru_nvcsw, memory_order_relaxed );
             } );
     for( size_t r = N; r; --r )
     {
         unique_lock lock( mtx );
         signalled = nClients;
         cv.notify_all();
         ai.store( nClients, memory_order_relaxed );
         lock.unlock();
         bs.acquire();
     }
     clients.resize( 0 );
     cout << N << " rounds," << endl;
     cout << (double)nVoluntary.load( memory_order_relaxed ) / nClients << " context switches pe thread" << endl;
}
 It spawns one less threads than ther are hardware threads. These
all wait for a condvar and a counter which is initially the number
of threads and that must be > 0 for the wait to succeed. This counter
is decremented by each thread. Then the threads decrement an atomic
and if it becomes zero the last thread raises a semaphore, thereby
waking up the main thread.
This are the results for 10'000 rounds on a 32-thread machine:
      10000 rounds,
     2777.29 context switches pe thread
 So there are less context-switches than rounds and there's no
thundering herd with glibc.