: m_Type(type)

, m_Count(0)

, m_WaitingThreadCount(0)

{

{

// IMPORTANT: This function must be exception-safe! APCs may throw.

ThreadImpl* currentThread = ThreadImpl::GetCurrentThread();

// Do up-front check about pending APC

if (interruptible)

currentThread->CheckForUserAPCAndHandle();

// Lock object. We release this mutex during waiting.

ReleaseOnDestroy lock(m_Mutex);

// See if the object is in a state where we can acquire it right away.

if (m_Count == 0)

{

// No, hasn't. If we're not supposed to wait, we're done.

if (timeoutMS == 0)

return kWaitStatusTimeout;

try

{

// We should wait. Let the world know this thread is now waiting

// on this object.

if (interruptible)

currentThread->SetWaitObject(this);

// Check APC queue again to avoid race condition.

if (interruptible)

currentThread->CheckForUserAPCAndHandle();

// Go into wait until we either have a release or timeout or otherwise fail.

int32_t remainingWaitTime = (int32_t)timeoutMS;

WaitStatus waitStatus = kWaitStatusSuccess;

while (m_Count == 0)

{

if (timeoutMS == kNoTimeout)

{

// Infinite wait. Can only be interrupted by APC.

++m_WaitingThreadCount; // No synchronization necessary; we hold the mutex.

ConditionWait(currentThread);

--m_WaitingThreadCount;

}

else

{

// Timed wait. Can be interrupted by APC or timeout.

const int64_t waitStartTime = Time::GetTicks100NanosecondsMonotonic();

++m_WaitingThreadCount;

bool wait_timedout = ConditionTimedWait(currentThread, remainingWaitTime);

--m_WaitingThreadCount; ////TODO: make this atomic for when we fail to reacquire the mutex

if (wait_timedout == false)

{

waitStatus = kWaitStatusTimeout;

break;

}

// Update time we have have left to wait.

const int32_t waitTimeThisRound = (int32_t)(Time::GetTicks100NanosecondsMonotonic() - waitStartTime) / 10000;

if (waitTimeThisRound > remainingWaitTime)

remainingWaitTime = 0;

else

remainingWaitTime -= waitTimeThisRound;

}

// We've received a signal but it may be because of an APC and not because

// the semaphore got signaled. If so, handle the APC and go back to waiting.

if (interruptible)

currentThread->CheckForUserAPCAndHandle();

}

// We're done waiting so untie us from the current thread.

// NOTE: A thread may have grabbed us and then got paused. If we return now and then our owner

// tries to delete us, we would pull the rug from under the other thread. This is prevented by

// having a central lock on wait object deletion which any thread trying to deal with wait

// objects from other threads has to acquire.

if (interruptible)

{

currentThread->SetWaitObject(NULL);

// Avoid race condition by checking APC queue again after unsetting wait object.

currentThread->CheckForUserAPCAndHandle();

}

// If we failed, bail out now.

if (waitStatus != kWaitStatusSuccess)

return waitStatus;

}

catch (...)

{

if (interruptible)

currentThread->SetWaitObject(NULL);

throw;

}

}

// At this point, we should be in signaled state and have the lock on

// the object.

// Object has been released. Acquire it for this thread.

IL2CPP_ASSERT(m_Count > 0);

switch (m_Type)

{

case kManualResetEvent:

// Nothing to do.

break;

case kMutex:

case kAutoResetEvent:

m_Count = 0;

break;

case kSemaphore:

if (m_Count > 0) // Defensive.

{

--m_Count;

if (m_Count > 0)

{

// There's more releases on the semaphore. Signal the next thread in line.

if (HaveWaitingThreads())

WakeupOneThread();

}

}

break;

}

return kWaitStatusSuccess;

{

SThreadPairPosix pair(thread, owner);

m_WaitingThreads.push_back(pair);

{

auto it = m_WaitingThreads.begin();

while (it != m_WaitingThreads.end())

{

if ((*it).thread == thread)

{

m_WaitingThreads.erase_swap_back(it);

break;

}

else

++it;

}

{

PushThreadToWaitersList(this, thread);

m_Mutex.Release();

thread->AcquireSemaphore();

m_Mutex.Acquire();

PopThreadFromWaitersList(thread);

{

PushThreadToWaitersList(this, thread);

m_Mutex.Release();

bool ret = thread->TryTimedAcquireSemaphore(timeout);

m_Mutex.Acquire();

PopThreadFromWaitersList(thread);

return ret;

{

// Wake up threads.

// We do this by iterating the waiters list and check if the owner (the semaphore, event or mutex) matches 'this'

// ie who is waiting for us specifically

// Mutex must be locked already by caller, see EventImpl::Set(), SemaphoreImpl::Post() and EventImpl::Set()

IL2CPP_ASSERT(m_Mutex.TryAcquire() == false);

int threadsWaiting = (int)m_WaitingThreads.size();

int threadsNotified = 0;

for (int i = 0; i < threadsWaiting; i++)

{

SThreadPairPosix* object = &m_WaitingThreads[i];

if (object->owner == this)

{

// a thread is stuck waiting for us, signal the thread semaphore

object->thread->ReleaseSemaphore();

// if only one wakeup is requested we exit here

if (wakeupOneThread)

break;

}

}