#include "il2cpp-config.h"
|
#include <vector>
|
#include <algorithm>
|
#include "icalls/mscorlib/System.Threading/WaitHandle.h"
|
#include "os/Mutex.h"
|
#include "os/Thread.h"
|
#include "vm/Thread.h"
|
#include "vm/Exception.h"
|
#include "vm/Array.h"
|
#include "vm/WaitHandle.h"
|
|
namespace il2cpp
|
{
|
namespace icalls
|
{
|
namespace mscorlib
|
{
|
namespace System
|
{
|
namespace Threading
|
{
|
std::vector<os::Handle*> ExtractOsWaitHandles(Il2CppArray* handles)
|
{
|
uint32_t numberOfHandles = vm::Array::GetLength(handles);
|
|
std::vector<os::Handle*> osWaitHandles(numberOfHandles);
|
|
for (uint32_t i = 0; i < numberOfHandles; ++i)
|
{
|
Il2CppObject* handle = il2cpp_array_get(handles, Il2CppObject*, i);
|
Il2CppWaitHandle* waitHandle = (Il2CppWaitHandle*)handle;
|
osWaitHandles[i] = vm::WaitHandle::GetPlatformHandle(waitHandle);
|
}
|
|
return osWaitHandles;
|
}
|
|
int32_t WaitHandle::WaitAny_internal(Il2CppArray* handles, int32_t ms, bool exitContext)
|
{
|
std::vector<os::Handle*> osWaitHandles = ExtractOsWaitHandles(handles);
|
|
vm::ThreadStateSetter state(vm::kThreadStateWaitSleepJoin);
|
|
return os::Handle::WaitAny(osWaitHandles, ms);
|
}
|
|
bool WaitHandle::WaitOne_internal(Il2CppObject* unused, intptr_t handlePtr, int32_t ms, bool exitContext)
|
{
|
il2cpp::os::Handle* handle = (il2cpp::os::Handle*)handlePtr;
|
|
vm::ThreadStateSetter state(vm::kThreadStateWaitSleepJoin);
|
|
// Check for pending interrupt before we go waiting.
|
il2cpp::vm::Thread::CheckCurrentThreadForInterruptAndThrowIfNecessary();
|
|
if (ms == -1)
|
return handle->Wait();
|
|
return handle->Wait((uint32_t)ms);
|
}
|
|
bool WaitHandle::WaitAll_internal(Il2CppArray* handles, int32_t ms, bool exitContext)
|
{
|
std::vector<os::Handle*> osWaitHandles = ExtractOsWaitHandles(handles);
|
|
vm::ThreadStateSetter state(vm::kThreadStateWaitSleepJoin);
|
|
return os::Handle::WaitAll(osWaitHandles, ms);
|
}
|
|
bool WaitHandle::SignalAndWait_Internal(intptr_t toSignal, intptr_t toWaitOn, int32_t ms, bool exitContext)
|
{
|
os::Handle* toSignalOsHandle = (os::Handle*)toSignal;
|
toSignalOsHandle->Signal();
|
|
return WaitOne_internal(NULL, toWaitOn, ms, exitContext);
|
}
|
|
int32_t WaitHandle::SignalAndWait_Internal40(intptr_t toSignal, intptr_t toWaitOn, int32_t ms)
|
{
|
return SignalAndWait_Internal(toSignal, toWaitOn, ms, false) ? 0 : 1;
|
}
|
|
#define MANAGED_WAIT_FAILED 0x7fffffff
|
#define MANAGED_WAIT_OBJECT_0 0x00000000
|
#define MANAGED_WAIT_TIMEOUT 258
|
#define MANAGED_WAIT_ABANDONED_0 0x00000080L
|
|
static int32_t map_native_wait_result_to_managed(UnityPalWaitStatus val, int32_t numobjects)
|
{
|
switch (val)
|
{
|
case kWaitStatusSuccess:
|
return MANAGED_WAIT_OBJECT_0 + val;
|
case kWaitStatusAbandoned:
|
return MANAGED_WAIT_ABANDONED_0 + val;
|
case kWaitStatusFailure:
|
return MANAGED_WAIT_FAILED;
|
case kWaitStatusTimeout:
|
return MANAGED_WAIT_TIMEOUT;
|
default:
|
return MANAGED_WAIT_FAILED;
|
}
|
}
|
|
int32_t WaitHandle::Wait_internal(void* *handles, int32_t numhandles, bool waitall, int32_t timeouts)
|
{
|
vm::ThreadStateSetter state(vm::kThreadStateWaitSleepJoin);
|
|
if (numhandles == 1)
|
{
|
os::WaitStatus status = ((os::Handle**)handles)[0]->Wait((uint32_t)timeouts, true);
|
|
// The managed code expects either success or timeout from this function, so
|
// throw away any other error codes.
|
if (status != kWaitStatusSuccess)
|
status = kWaitStatusTimeout;
|
return map_native_wait_result_to_managed(status, 1);
|
}
|
|
std::vector<os::Handle*> osWaitHandles((os::Handle**)handles, (os::Handle**)handles + numhandles);
|
|
if (waitall)
|
{
|
if (os::Handle::WaitAll(osWaitHandles, timeouts))
|
{
|
return map_native_wait_result_to_managed(kWaitStatusSuccess, numhandles);
|
}
|
else
|
{
|
return map_native_wait_result_to_managed(kWaitStatusTimeout, numhandles);
|
}
|
}
|
else
|
return os::Handle::WaitAny(osWaitHandles, timeouts);
|
}
|
} /* namespace Threading */
|
} /* namespace System */
|
} /* namespace mscorlib */
|
} /* namespace icalls */
|
} /* namespace il2cpp */
|
