Bonita Montero wrote:
> Am 26.09.2023 um 17:24 schrieb Scott Lurndal:
>
>> No, it is not.   The kernel simply moves the waiter thread to
>> a non-runnable queue in the dispatcher until a call to 'unlock'
>> determines that there is a waiter and tells the kernel to
>> awaken it.
>
> The userspace code must tell the kernel what it its waiting for.
> Mutexes are always a combination of an atomic for the fast path
> and a binary semapohre for the slow path.
>
see my or Kaz's explanation for how it is done without allocating any
kernel resource on either initialization or locking, either fast or slow
path.

On 9/28/2023 6:40 PM, Pavel wrote:
> Bonita Montero wrote:
>> Am 26.09.2023 um 17:25 schrieb Scott Lurndal:
>>
>>> No, there is no delayed initialization with pthread mutexes.
>>
>> There must be since you can't create a semaphore by pure assignment.
>>
> See mine or earlier Kaz's explanations above for how you actually can do
> it (and how, iirc, it is done on Linux).

Right.

On 9/25/2023 9:21 AM, Bonita Montero wrote:
> Am 25.09.2023 um 17:51 schrieb Scott Lurndal:
>> Bonita Montero <Bonita.Montero@gmail.com> writes:
>
>
>>> lock() and unlock() might throw system_error.
>
>> lock() and unlock() cannot throw any error.
>
> https://en.cppreference.com/w/cpp/thread/mutex/lock
>
>     "Throws std::system_error when errors occur, including errors
>     from the underlying operating system that would prevent lock
>     from meeting its specifications. The mutex is not locked in
>     the case of any exception being thrown."
>
> https://en.cppreference.com/w/cpp/thread/mutex/unlock
>
>     "Throws nothing"
>
> You're right only in the latter case.
>

Study up Bonita!!!! Damn it.

On 9/25/2023 4:29 PM, Richard Damon wrote:
> On 9/25/23 12:11 PM, Bonita Montero wrote:
>> Am 25.09.2023 um 13:15 schrieb Richard Damon:
>>
>>> You argument is basically, the Standard needs to allow for BAD
>>> implementation to exist.
>>
>> And implementation that throws in this situation isn't bad for me.
>
> So, you don't mind you code not working as promised.
>
> I guess you don't have to write code that actually works.

The sick joke aspect.... Humm.... ;^o

Am 29.09.2023 um 03:46 schrieb Pavel:

> see my or Kaz's explanation for how it is done without allocating any
> kernel resource on either initialization or locking, either fast or slow
> path.

.... on Linux with signals.

Am 28.09.2023 um 23:34 schrieb Michael S:

> My tests use small # of threads (3), but can wait, sequentially, on lots
> of critical sections.

The kernel-resources are only allocated on contention.

On Friday, September 29, 2023 at 3:03:30 PM UTC+3, Bonita Montero wrote:
> Am 28.09.2023 um 23:34 schrieb Michael S:
>
> > My tests use small # of threads (3), but can wait, sequentially, on lots
> > of critical sections.
> The kernel-resources are only allocated on contention.

I care to assure contention.

Am 29.09.2023 um 14:07 schrieb Michael S:

> I care to assure contention.

Foreach critical section you'd need a blocking thread and one thread
which holds the lock, not only three for thousands of critical sections.

On Friday, September 29, 2023 at 3:15:57 PM UTC+3, Bonita Montero wrote:
> Am 29.09.2023 um 14:07 schrieb Michael S:
>
> > I care to assure contention.
> Foreach critical section you'd need a blocking thread and one thread
> which holds the lock, not only three for thousands of critical sections.

You wanted to see code, I showed you code. As expected, you didn't understand.

Am 29.09.2023 um 14:37 schrieb Michael S:

> You wanted to see code, I showed you code. As expected, you didn't understand.

To enforce delayed creation you have to contend. And if you contend
you're going to sleep. So the minimum approach would be to have one
thread owning the critical sections and for each critical section a
contending thread. There's no way to enforce delayed creation for a
large number of critical sections with a small number of threads.
And you absolutely don't need to use thread priorities or affinities
here.

Michael S <already5chosen@yahoo.com> writes:

> On Friday, September 29, 2023 at 3:15:57?PM UTC+3, Bonita Montero wrote:
>
>> Am 29.09.2023 um 14:07 schrieb Michael S:
>>
>>> I care to assure contention.
>>
>> Foreach critical section you'd need a blocking thread and one
>> thread which holds the lock, not only three for thousands of
>> critical sections.
>
> You wanted to see code, I showed you code. As expected, you didn't
> understand.

To me the real question is why you bother to respond
to Bonita at all, or even read his/her/its postings.
You are obviously a smart guy, I hope you have better
things to do.

Am 29.09.2023 um 17:03 schrieb Tim Rentsch:

> To me the real question is why you bother to respond
> to Bonita at all, or even read his/her/its postings.
> You are obviously a smart guy, I hope you have better
> things to do.

Yes, take measurements incorrectly.

On 9/29/2023 8:03 AM, Tim Rentsch wrote:
> Michael S <already5chosen@yahoo.com> writes:
>
>> On Friday, September 29, 2023 at 3:15:57?PM UTC+3, Bonita Montero wrote:
>>
>>> Am 29.09.2023 um 14:07 schrieb Michael S:
>>>
>>>> I care to assure contention.
>>>
>>> Foreach critical section you'd need a blocking thread and one
>>> thread which holds the lock, not only three for thousands of
>>> critical sections.
>>
>> You wanted to see code, I showed you code. As expected, you didn't
>> understand.
>
> To me the real question is why you bother to respond
> to Bonita at all, or even read his/her/its postings.
> You are obviously a smart guy, I hope you have better
> things to do.

I am trying to urge Michael to give Relacy Race Detector a go, for fun
on his free time. Free time meaning very bored with nothing to do.

https://www.1024cores.net/home/relacy-race-detector

https://github.com/dvyukov/relacy

Am 29.09.2023 um 20:44 schrieb Chris M. Thomasson:

> I am trying to urge Michael to give Relacy Race Detector a go, for
> fun on his free time. Free time meaning very bored with nothing to do.

You always have objections that have nothing directly to do with
the topic. I think his code is also ugly because it's bare C and
in C++ the code would be one third in size, but I don't feel that
uncertain like you to make such objections.

On 9/29/2023 11:54 AM, Bonita Montero wrote:
> Am 29.09.2023 um 20:44 schrieb Chris M. Thomasson:
>
>> I am trying to urge Michael to give Relacy Race Detector a go, for
>> fun  on his free time. Free time meaning very bored with nothing to do.
>
> You always have objections that have nothing directly to do with
> the topic.

How is what I wrote, an objection? Objection to what!?

> I think his code is also ugly because it's bare C and
> in C++ the code would be one third in size, but I don't feel that
> uncertain like you to make such objections.
>

If __you__ think the code is ugly, so be it. Don't project on me, Bonita.

On 9/29/2023 11:54 AM, Bonita Montero wrote:
> Am 29.09.2023 um 20:44 schrieb Chris M. Thomasson:
>
>> I am trying to urge Michael to give Relacy Race Detector a go, for
>> fun  on his free time. Free time meaning very bored with nothing to do.
>
> You always have objections that have nothing directly to do with
> the topic. I think his code is also ugly because it's bare C and
> in C++ the code would be one third in size, but I don't feel that
> uncertain like you to make such objections.
>

Bonita, you have a lot to learn about synchronization algorithms... I
have read what you wrote, and well, you would be fired from the team. I
have tried to help you, but you always try to shut me down. So be it.
Fine with me. I am starting to wonder why I am casting pearls before
swine, so to speak... ;^o

Am 29.09.2023 um 21:00 schrieb Chris M. Thomasson:

> Bonita, you have a lot to learn about synchronization algorithms... I

Write sth. like that:

// header:

#pragma once
#include <cstdint>
#include <cassert>
#include <thread>
#include <new>
#include <atomic>
#include <stdexcept>
#include <exception>
#include <limits>
#include <cstdint>
#include <semaphore>
#include <string>
#include <optional>
#include "thread_id.h"
#include "msvc-disabler.h"

#if defined(__llvm__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdangling-else"
#endif

struct wbias_shared_mutex;

struct wbsm_exception : public std::exception
{ enum reason
{
SHARER_COUNTER_SATURATED = 1,
WATING_EXCLUSIVE_COUNTER_SATURATED = 2,
RECURSION_COUNTER_SATURATED = 3
};
wbsm_exception() = delete;
wbsm_exception( wbsm_exception const & ) = default;
reason get_reason();
virtual char const *what() const noexcept;
private:
friend struct wbias_shared_mutex;
wbsm_exception( reason r, char const *what );
reason m_reason;
std::string m_what;
};

inline wbsm_exception::wbsm_exception( reason r, char const *what ) :
m_reason( r ),
m_what( what )
{ }

inline wbsm_exception::reason wbsm_exception::get_reason()
{ return m_reason;
}

static_assert(std::atomic<uint64_t>::is_always_lock_free, "uint64_t must
be lock-free");

struct
#if defined(__cpp_lib_hardware_interference_size)
alignas(std::hardware_destructive_interference_size)
#else
alignas(64)
#endif
wbias_shared_mutex
{ wbias_shared_mutex( int16_t maxExclusiveSpinCount = 0, int16_t
maxSharedSpinCount = 0 );
wbias_shared_mutex( wbias_shared_mutex const & ) = delete;
void operator =( wbias_shared_mutex const & ) = delete;
~wbias_shared_mutex();
void lock_shared( bool force = false );
bool try_lock_shared( bool force = false );
void unlock_shared();
void shared_to_exclusive( thread_id threadId = thread_self() );
void lock_exclusive( thread_id threadId = thread_self() );
bool try_lock_exclusive( thread_id threadId = thread_self() );
bool lock_preferred_shared( bool force = false, thread_id threadId =
thread_self() );
void unlock_exclusive( thread_id threadId = thread_self() );
void exclusive_to_shared( bool force = false );
bool is_shared();
bool is_exclusive();
bool we_are_exclusive( thread_id threadId = thread_self() );
thread_id get_exclusive_thread_id();
uint32_t get_exclusive_recursion_count();
int16_t max_exclusive_spin_count( int16_t max = 100 );
int16_t max_shared_spin_count( int16_t max = 100 );
private:
static_assert(std::atomic<uint64_t>::is_always_lock_free,
"std::atomic<uint64_t> must be always lock-free");
std::atomic<uint64_t> m_atomic;
std::atomic<thread_id> m_exclusiveId;
std::atomic_uint32_t m_exclusiveRecursionCount;
std::atomic_int16_t m_exclusiveSpinCount, m_sharedSpinCount; //
adaptive spinning taken from glibc
std::atomic_int16_t m_maxExclusiveSpinCount, m_maxSharedSpinCount;
std::counting_semaphore<(1 << 21) - 1> m_releaseSharedSem;
std::binary_semaphore m_releaseExclusiveSem;
static unsigned const
WAITING_SHARERS_BASE = 21,
WAITING_EXCLUSIVE_BASE = 2 * 21,
EXCLUSIVE_FLAG_BASE = 3 * 21;
static constexpr uint64_t
MASK21 = 0x1FFFFFu,
SHARERS_MASK = MASK21,
WAITING_SHARERS_MASK = MASK21 << WAITING_SHARERS_BASE,
WAITING_EXCLUSIVE_MASK = MASK21 << WAITING_EXCLUSIVE_BASE,
EXCLUSIVE_FLAG_MASK = (uint64_t)1 << EXCLUSIVE_FLAG_BASE,
SHARER_VALUE = (uint64_t)1,
WAITING_SHARERS_VALUE = (uint64_t)1 << WAITING_SHARERS_BASE,
WAITING_EXCLUSIVE_VALUE = (uint64_t)1 << WAITING_EXCLUSIVE_BASE;
static constexpr short DEFAULT_MAX_SPIN_COUNT = 100;
#if !defined(NDEBUG)
static bool check( uint64_t flags );
#endif
bool internalSpinLockShared( uint64_t &cmp, bool force );
void internalLockShared( uint64_t cmp, bool force );
bool internalSpinLockExclusive( uint64_t &cmp, thread_id threadId );
void cpuPause();
};

inline bool wbias_shared_mutex::is_shared()
{ return m_atomic.load( std::memory_order_relaxed ) & SHARERS_MASK;
}

inline bool wbias_shared_mutex::is_exclusive()
{ return m_atomic.load( std::memory_order_relaxed ) & EXCLUSIVE_FLAG_MASK;
}

inline bool wbias_shared_mutex::we_are_exclusive( thread_id threadId )
{ return (m_atomic.load( std::memory_order_relaxed ) & EXCLUSIVE_FLAG_MASK)
&& m_exclusiveId.load( std::memory_order_relaxed ) == threadId;
}

inline thread_id wbias_shared_mutex::get_exclusive_thread_id()
{ //std::atomic_thread_fence( std::memory_order_acquire );
return m_exclusiveId.load( std::memory_order_relaxed );
}

inline uint32_t wbias_shared_mutex::get_exclusive_recursion_count()
{ return m_exclusiveRecursionCount.load( std::memory_order_relaxed );
}

struct wbsm_lock
{ enum
{
UNLOCKED,
SHARED,
EXLUSIVE
};
wbsm_lock();
wbsm_lock( wbsm_lock const &other );
wbsm_lock( wbsm_lock &&other ) noexcept;
wbsm_lock( wbias_shared_mutex &mtx, bool lockShared = true, thread_id
threadId = thread_self() );
~wbsm_lock();
wbsm_lock &operator =( wbsm_lock const &other );
wbsm_lock &operator =( wbsm_lock &&other ) noexcept;
void lock_shared( wbias_shared_mutex &mtx );
void shared_to_exclusive( thread_id threadId = thread_self() );
void exclusive_to_shared( bool force = false );
void lock_exclusive( wbias_shared_mutex &mtx, thread_id threadId =
thread_self() );
void unlock();
void lock_preferred_shared( wbias_shared_mutex &mtx, thread_id threadId
= thread_self() );
bool is_locked() const;
bool is_shared() const;
bool is_exclusive() const;
thread_id get_exclusive_thread_id() const;
wbias_shared_mutex *get_mutex() const;
std::pair<int, wbias_shared_mutex *> get_state() const;
void set_state( int state, wbias_shared_mutex *pMtx );
private:
wbias_shared_mutex *m_mtx;
bool m_isShared;
thread_id m_threadId;
};

inline wbsm_lock::wbsm_lock()
{ m_mtx = nullptr;
}

inline wbsm_lock::wbsm_lock( wbsm_lock &&other ) noexcept :
m_mtx( other.m_mtx ),
m_isShared( other.m_isShared ),
m_threadId( other.m_threadId )
{ other.m_mtx = nullptr;
#if !defined(NDEBUG)
other.m_threadId = 0;
#endif
}

inline bool wbsm_lock::is_locked() const
{ return m_mtx != nullptr;
}

inline bool wbsm_lock::is_shared() const
{ assert(m_mtx);
return m_isShared;
}

inline bool wbsm_lock::is_exclusive() const
{ assert(m_mtx);
return !m_isShared;
}

inline thread_id wbsm_lock::get_exclusive_thread_id() const
{ return m_threadId;
}

inline wbias_shared_mutex *wbsm_lock::get_mutex() const
{ return m_mtx;
}

#if defined(__llvm__)
#pragma clang diagnostic pop
#endif

// source:

#include <utility>
#include "wbias_shared_mutex.h"
#include "xassert.h"
#include "exc_encapsulate.h"
#if defined(_MSC_VER)
#include <intrin.h>
#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
#include <immintrin.h>
#endif
#if defined(__llvm__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdangling-else"
#endif

char const *wbsm_exception::what() const noexcept
{ return m_what.c_str();
}

#if !defined(NDEBUG)
inline bool wbias_shared_mutex::check( std::uint64_t flags )
{ unsigned
sharers = (unsigned)(flags & MASK21),
waitingExclusive = (unsigned)((flags >> WAITING_EXCLUSIVE_BASE) & MASK21),
exclusiveFlag = (unsigned)((flags >> EXCLUSIVE_FLAG_BASE) & 1);
if( sharers && exclusiveFlag )
return false;
if( waitingExclusive && !exclusiveFlag && !sharers )
return false;
return true;
} #endif

wbias_shared_mutex::wbias_shared_mutex( int16_t maxExclusiveSpinCount,
int16_t maxSharedSpinCount ) :
m_atomic( 0 ),
m_exclusiveId(),
m_exclusiveSpinCount( 0 ),
m_sharedSpinCount( 0 ),
m_maxExclusiveSpinCount( maxExclusiveSpinCount ),
m_maxSharedSpinCount( maxSharedSpinCount ),
m_releaseSharedSem( 0 ),
m_releaseExclusiveSem( false )
{ }

wbias_shared_mutex::~wbias_shared_mutex()
{ assert(!m_atomic);
}

// throws wbsm_exception if waiting sharers counter saturates

void wbias_shared_mutex::lock_shared( bool force )
{ using namespace std;
uint64_t cmp = m_atomic.load( memory_order_relaxed );
if( internalSpinLockShared( cmp, force ) )
return;
internalLockShared( cmp, force );
}

inline bool wbias_shared_mutex::internalSpinLockShared( std::uint64_t
&cmp, bool force )
{ using namespace std;
int16_t maxSharedSpinCount = m_maxSharedSpinCount.load(
memory_order_relaxed );
if( maxSharedSpinCount <= 0 )
return false;
int16_t sharedSpinCount = m_sharedSpinCount.load( memory_order_relaxed );
int32_t spinLimit = (int32_t)sharedSpinCount * 2 + 10;
spinLimit = spinLimit <= maxSharedSpinCount ? spinLimit :
maxSharedSpinCount;
int32_t spinCount = 0;
bool locked = false;
for( ; ; )
{
assert(check( cmp ));
if( !(cmp & (EXCLUSIVE_FLAG_MASK | (!force ? WAITING_EXCLUSIVE_MASK :
0))) )
if( (cmp & SHARERS_MASK) == SHARERS_MASK )
break;
else if( m_atomic.compare_exchange_weak( cmp, cmp + SHARER_VALUE,
memory_order_acquire, memory_order_relaxed ) )
{
locked = true;
break;
}
if( ++spinCount >= spinLimit )
break;
cpuPause();
cmp = m_atomic.load( memory_order_relaxed );
}
m_sharedSpinCount.store( sharedSpinCount + ((int16_t)spinCount -
sharedSpinCount) / 8, memory_order_relaxed );
return locked;
}

On 9/29/2023 12:09 PM, Bonita Montero wrote:
> Am 29.09.2023 um 21:00 schrieb Chris M. Thomasson:
>
>> Bonita, you have a lot to learn about synchronization algorithms... I
>
> Write sth. like that:
[...]

Run it through a race detector, make sure it works.

On 9/29/2023 12:26 PM, Chris M. Thomasson wrote:
> On 9/29/2023 12:09 PM, Bonita Montero wrote:
>> Am 29.09.2023 um 21:00 schrieb Chris M. Thomasson:
>>
>>> Bonita, you have a lot to learn about synchronization algorithms... I
>>
>> Write sth. like that:
> [...]
>
> Run it through a race detector, make sure it works.
>

It's good to do that. Why are you so against using a race detector?

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

> Run it through a race detector, make sure it works.

Your only answer to any MT-code that overburdens you is:
use a race detector.

Am 29.09.2023 um 21:27 schrieb Chris M. Thomasson:

> It's good to do that. Why are you so against using a race detector?

MT-primitives are hard to debug, so they need
to be designed with a clearer mind than yours.

On 9/29/2023 12:31 PM, Bonita Montero wrote:
> Am 29.09.2023 um 21:27 schrieb Chris M. Thomasson:
>
>> It's good to do that. Why are you so against using a race detector?
>
> MT-primitives are hard to debug, so they need
> to be designed with a clearer mind than yours.
>

Huh? Run your code through a race detector and we can go from there. You
want me to try to find a bug in the code you posted? Well, pay me.

On 9/29/2023 12:30 PM, Bonita Montero wrote:
> Am 29.09.2023 um 21:26 schrieb Chris M. Thomasson:
>
>> Run it through a race detector, make sure it works.
>
> Your only answer to any MT-code that overburdens you is:
> use a race detector.
>

Huh? Lets make sure it passes some tests, then we can dig into it. There
could be a false negative. I don't think you like to test any of your
own code. Just throwing some example runs at it is not enough.

Am 29.09.2023 um 21:34 schrieb Chris M. Thomasson:

> Huh? Run your code through a race detector and we can go from there.
> You want me to try to find a bug in the code you posted? Well, pay me.

Idiot !

On 9/29/2023 12:36 PM, Chris M. Thomasson wrote:
> On 9/29/2023 12:30 PM, Bonita Montero wrote:
>> Am 29.09.2023 um 21:26 schrieb Chris M. Thomasson:
>>
>>> Run it through a race detector, make sure it works.
>>
>> Your only answer to any MT-code that overburdens you is:
>> use a race detector.
>>
>
> Huh? Lets make sure it passes some tests, then we can dig into it. There
> could be a false negative. I don't think you like to test any of your
> own code. Just throwing some example runs at it is not enough.

Say, a race detector finds a race condition in your code. You examine it
and can _prove_ that it works, well, then the race detector was wrong.
We can now dive into it.