Re: WaitForSingleObject() will not deadlock

A synchronization primitive without memory visibility guarantee CANNOT be
used to synchronize access to some data set, thus it's pretty much useless.
You might as well not use it at all, with the same result.

Atomic functions (at least on x86 and x64), DO provide memory fence.
CRITICAL_SECTION simply uses InterlockedCompareExchange. I think
pthread_mutex is no different.

Having said that, implementation of reentrant intra-thread mutex primitive
is VERY trivial. You can cook such a thing in 10 minutes:

struct MY_CRITICAL_SECTION
{
    LONG OwningThreadID;
    LONG ReentranceCount;
    LONG ContentionCount;
    HANDLE hEvent;
};

void MyEnterCriticalSection(MY_CRITICAL_SECTION * p)
{
    LONG CurrentThreadID = GetCurrentThreadId();
    while (1)
    {
        InterlockedIncrement( & p->ContentionCount);
        LONG OwnerID = InterlockedCompareExchangeAcquire( &
p->OwningThreadID, CurrentThreadID, 0);
        if (CurrentThreadID == OwnerID)
        {
            // recursive entrance
            InterlockedDecrement( & p->ContentionCount);
            p->ReentranceCount++;
            return;
        }
        if (OwnerID == 0)
        {
            // was not owned. We own it now
            InterlockedDecrement( & p->ContentionCount);
            p->ReentranceCount++;
            return;
        }
        KeWaitForSingleObject(p->hEvent, INFINITE);
    }
}

void MyLeaveCriticalSection(MY_CRITICAL_SECTION * p)
{
    ASSERT(GetCurrentThreadId() == p->OwningThreadID);

    p->ReentranceCount--;

    if (p->ReentranceCount== 0)
    {
        // we don't own it anymore
        p->OwningThreadID= 0;
        if (0 != InterlockedExchange(p->ContentionCount, 0))
        {
            SetEvent(p->hEvent);
        }
    }
}

Note that it DOES privide memory visibility.

"Frank Cusack" <fcusack@fcusack.com> wrote in message
news:m24pkn2szi.fsf@sucksless.local...