#include "il2cpp-config.h"

#include "il2cpp-class-internals.h"

#include "il2cpp-api.h"

#include "il2cpp-object-internals.h"

#include "vm/Array.h"

#include "vm/Class.h"

#include "vm/Exception.h"

#include "vm/Image.h"

#include "vm/Object.h"

#include "vm/Thread.h"

#include "vm/ThreadPool.h"

#include "vm/WaitHandle.h"

#include "os/Atomic.h"

#include "os/Environment.h"

#include "os/Event.h"

#include "os/Mutex.h"

#include "os/Semaphore.h"

#include "os/Socket.h"

#include "os/Thread.h"

#include "gc/Allocator.h"

#include "gc/GCHandle.h"

#include "utils/Memory.h"

#include "icalls/System/System.Net.Sockets/Socket.h"

#include <queue>

#include <vector>

#include <list>

#include <limits>

#include <algorithm>

#if IL2CPP_TARGET_POSIX

#include <unistd.h>

#include "os/Posix/PosixHelpers.h"

#elif IL2CPP_TARGET_WINDOWS

#include "os/Win32/WindowsHeaders.h"

#include "os/Win32/ThreadImpl.h"

#include <winsock2.h>

#endif

#if IL2CPP_USE_SOCKET_MULTIPLEX_IO

#include "MultiplexIO.h"

#endif

namespace il2cpp

{

namespace vm

{

enum

{

THREADS_PER_CORE = 10

};

typedef gc::Allocator<Il2CppAsyncResult*> AsyncResultAllocator;

typedef std::list<Il2CppAsyncResult*, AsyncResultAllocator> AsyncResultList;

typedef std::vector<Il2CppAsyncResult*, AsyncResultAllocator> AsyncResultVector;

typedef std::queue<Il2CppAsyncResult*, AsyncResultList> AsyncResultQueue;

static const Il2CppClass* g_SocketAsyncCallClass;

static const Il2CppClass* g_ProcessAsyncCallClass;

static const Il2CppClass* g_WriteDelegateClass;

static const Il2CppClass* g_ReadDelegateClass;

static bool IsInstanceOfDelegateClass(Il2CppDelegate* delegate, const char* delegateClassName, const char* outerClassName, const Il2CppClass*& cachePtr)

}

static bool IsSocketAsyncCall(Il2CppDelegate* delegate)

{

return IsInstanceOfDelegateClass(delegate, "SocketAsyncCall", "Socket", g_SocketAsyncCallClass);

}

static bool IsProcessAsyncCall(Il2CppDelegate* delegate)

{

return IsInstanceOfDelegateClass(delegate, "AsyncReadHandler", "Process", g_ProcessAsyncCallClass);

}

static bool IsFileStreamAsyncCall(Il2CppDelegate* delegate)

}

enum

{

AIO_OP_FIRST,

AIO_OP_ACCEPT = 0,

AIO_OP_CONNECT,

AIO_OP_RECEIVE,

AIO_OP_RECEIVEFROM,

AIO_OP_SEND,

AIO_OP_SENDTO,

AIO_OP_RECV_JUST_CALLBACK,

AIO_OP_SEND_JUST_CALLBACK,

AIO_OP_READPIPE,

AIO_OP_LAST

};

struct SocketPollingThread

{

os::FastMutex mutex;

AsyncResultQueue queue;

os::Thread* thread;

os::Event threadStartupAcknowledged;

#if IL2CPP_USE_SOCKET_MULTIPLEX_IO

Sockets::MultiplexIO multiplexIO; // container class to allow access to multiplex io socket functions

#elif IL2CPP_TARGET_POSIX || IL2CPP_TARGET_WINDOWS

/// On POSIX, we have no way to interrupt polls() with user APCs in a way that isn't prone

/// to race conditions so what we do instead is create a pipe that we include in the poll()

/// call and then write to that in order to interrupt an ongoing poll().

///

/// On Windows, we used to do QueueUserAPC and throw an exception in order to interrupt poll(),

/// however, that is not safe and corrupts memory/leaves dangling pointers to the stack as

/// WinSock2 is not exception safe. So we do it in a similar way as POSIX, but instead of pipes

/// we use sockets.

enum

{

kMessageTerminate,

kMessageNewAsyncResult

};

#if IL2CPP_TARGET_POSIX

typedef int PipeType;

#elif IL2CPP_TARGET_WINDOWS

typedef SOCKET PipeType;

#endif

PipeType readPipe;

PipeType writePipe;

static inline void WritePipe(PipeType pipe, char message)

}

static inline char ReadPipe(PipeType pipe, char* message, int length)

}

#endif

SocketPollingThread()

: threadStartupAcknowledged(true)

, thread(NULL)

#if !IL2CPP_USE_SOCKET_MULTIPLEX_IO && (IL2CPP_TARGET_POSIX || IL2CPP_TARGET_WINDOWS)

, readPipe(0)

, writePipe(0)

#endif

{

}

void QueueRequest(Il2CppAsyncResult* asyncResult)

{

// Put in queue.

{

os::FastAutoLock lock(&mutex);

queue.push(asyncResult);

gc::GarbageCollector::SetWriteBarrier((void**)&queue.back());

}

// Interrupt polling thread to pick up new request.

#if IL2CPP_USE_SOCKET_MULTIPLEX_IO

multiplexIO.InterruptPoll(); // causes the current blocking poll to abort and recheck the queue

#elif IL2CPP_TARGET_POSIX || IL2CPP_TARGET_WINDOWS

char message = static_cast<char>(kMessageNewAsyncResult);

WritePipe(writePipe, message);

#endif

}

Il2CppAsyncResult* DequeueRequest()

{

os::FastAutoLock lock(&mutex);

if (queue.empty())

return NULL;

Il2CppAsyncResult* asyncResult = queue.front();

queue.pop();

return asyncResult;

}

bool ResultReady()

}

void RunLoop();

void Terminate();

};

struct ThreadPoolCompartment

};

enum

{

kWorkerThreadPool,

kAsyncIOPool,

kNumThreadPoolCompartments

};

static ThreadPoolCompartment* g_ThreadPoolCompartments[kNumThreadPoolCompartments];

static SocketPollingThread* g_SocketPollingThread;

#if IL2CPP_TARGET_POSIX && !IL2CPP_USE_SOCKET_MULTIPLEX_IO

typedef pollfd NativePollRequest;

#else

typedef os::PollRequest NativePollRequest;

#endif

static Il2CppSocketAsyncResult* GetSocketAsyncResult(Il2CppAsyncResult* asyncResult)

{

////TODO: assert

return reinterpret_cast<Il2CppSocketAsyncResult*>(asyncResult->async_state);

}

static bool IsSocketAsyncOperation(Il2CppAsyncResult* asyncResult)

}

static void InitPollRequest(NativePollRequest& request, Il2CppSocketAsyncResult* socketAsyncResult, os::SocketHandleWrapper& socketHandle)

}

void SocketPollingThread::RunLoop()

{

#if !IL2CPP_USE_SOCKET_MULTIPLEX_IO && !IL2CPP_TARGET_POSIX && !IL2CPP_TARGET_WINDOWS

IL2CPP_ASSERT(false && "Platform has no SocketPollingThread mechanism. This function WILL deadlock.");

#endif

#if IL2CPP_TARGET_POSIX && !IL2CPP_USE_SOCKET_MULTIPLEX_IO

const short kNativePollIn = POLLIN;

#else

const os::PollFlags kNativePollIn = os::kPollFlagsIn;

#endif

// List of poll requests that we pass to os::Socket::Poll().

std::vector<NativePollRequest> pollRequests;

// List of AsyncResults corresponding to pollRequests. Needs to be its own list as

// this is memory that we need the GC to scan.

AsyncResultVector asyncResults;

// List of socket handles we're currently using. If destructed, will automatically

// release all sockets.

std::vector<os::SocketHandleWrapper> socketHandles;

#if !IL2CPP_USE_SOCKET_MULTIPLEX_IO && (IL2CPP_TARGET_POSIX || IL2CPP_TARGET_WINDOWS)

{

NativePollRequest pollRequest;

pollRequest.fd = readPipe;

pollRequest.events = kNativePollIn;

pollRequest.revents = os::kPollFlagsNone;

pollRequests.push_back(pollRequest);

// Push back dummy values to asyncResults and socketHandles so their indices match pollrequest indices

asyncResults.push_back(NULL);

gc::GarbageCollector::SetWriteBarrier((void**)asyncResults.data(), asyncResults.size() * sizeof(Il2CppAsyncResult));

socketHandles.push_back(os::SocketHandleWrapper());

}

#endif

// Let other threads know we're ready to take requests.

threadStartupAcknowledged.Set();

while (true)

{

// See if there's anything new in the queue.

while (ResultReady())

{

// Grab next request.

Il2CppAsyncResult* asyncResult = DequeueRequest();

if (!asyncResult)

break;

Il2CppSocketAsyncResult* socketAsyncResult = GetSocketAsyncResult(asyncResult);

// Add socket handle.

socketHandles.push_back(os::SocketHandleWrapper());

os::SocketHandleWrapper& socketHandle = socketHandles.back();

asyncResults.push_back(asyncResult);

gc::GarbageCollector::SetWriteBarrier((void**)asyncResults.data(), asyncResults.size() * sizeof(Il2CppAsyncResult));

// Add the request to the list.

NativePollRequest pollRequest;

InitPollRequest(pollRequest, socketAsyncResult, socketHandle);

pollRequests.push_back(pollRequest);

}

// Poll the list.

#if IL2CPP_USE_SOCKET_MULTIPLEX_IO

int32_t errorCode = 0;

int32_t results = 0;

multiplexIO.Poll(pollRequests, -1, &results, &errorCode);

#elif IL2CPP_TARGET_POSIX || IL2CPP_TARGET_WINDOWS

#if IL2CPP_TARGET_POSIX

os::posix::Poll(pollRequests.data(), pollRequests.size(), -1);

#else

int32_t result, error;

os::Socket::Poll(pollRequests, -1, &result, &error);

#endif

if (pollRequests[0].revents != os::kPollFlagsNone)

{

char message;

if (ReadPipe(readPipe, &message, 1) == 1 && message == kMessageTerminate)

throw vm::Thread::NativeThreadAbortException();

}

#endif

// Go through our requests and see which ones we can forward, which ones are

// obsolete, and which ones still need to be waited on.

#if IL2CPP_USE_SOCKET_MULTIPLEX_IO || (!IL2CPP_TARGET_POSIX && !IL2CPP_TARGET_WINDOWS)

const size_t startIndex = 0;

#else

const size_t startIndex = 1;

#endif

for (size_t i = startIndex; i < pollRequests.size();)

{

// See if there's been some activity that allows us to forward the request

// to the thread pool. We don't care what event(s) exactly happened on the

// socket and the socket may even have been closed already. All we want is

// to forward a socket to the pool as soon as there is some activity and then

// have the normal processing chain sort out what kind of activity that was.

if (pollRequests[i].revents)

{

// Yes.

g_ThreadPoolCompartments[kAsyncIOPool]->QueueWorkItem(asyncResults[i]);

pollRequests.erase(pollRequests.begin() + i);

asyncResults.erase(asyncResults.begin() + i);

gc::GarbageCollector::SetWriteBarrier((void**)asyncResults.data(), asyncResults.size() * sizeof(Il2CppAsyncResult));

socketHandles.erase(socketHandles.begin() + i);

}

else

{

++i;

}

}

}

}

static void FreeThreadHandle(void* data)

}

#if IL2CPP_TARGET_WINDOWS

struct ConnectToSocketArgs

};

static void ConnectToSocket(void* arg)

}

#endif

static void SocketPollingThreadEntryPoint(void* data)

}

static void SpawnSocketPollingThreadIfNeeded()

}

void SocketPollingThread::Terminate()

{

#if IL2CPP_TARGET_WINDOWS || IL2CPP_TARGET_POSIX

if (!g_SocketPollingThread->thread)

return;

#if !IL2CPP_USE_SOCKET_MULTIPLEX_IO

WritePipe(writePipe, static_cast<char>(kMessageTerminate));

#endif

g_SocketPollingThread->thread->Join();

#endif

}

static bool IsCurrentThreadAWorkerThread()

}

void ThreadPoolCompartment::QueueWorkItem(Il2CppAsyncResult* asyncResult)

{

bool forceNewThread = false;

// Put the item in the queue.

{

os::FastAutoLock lock(&mutex);

queue.push(asyncResult);

gc::GarbageCollector::SetWriteBarrier((void**)&queue.back());

IL2CPP_ASSERT(numIdleThreads >= 0);

if (queue.size() > static_cast<uint32_t>(numIdleThreads))

forceNewThread = true;

}

// If all our worker threads are tied up and we have room to grow, spawn a

// new worker thread. Also, if an item is queued from within a work item that

// is currently being processed and we don't have idle threads, force a new

// thread to be spawned even if we are at max capacity. This prevents deadlocks

// if the code queuing the item then goes and waits on the item it just queued.

IL2CPP_ASSERT(maxThreads >= 0);

if (forceNewThread &&

(threads.size() < static_cast<uint32_t>(maxThreads) || IsCurrentThreadAWorkerThread()))

{

SpawnNewWorkerThread();

}

else

{

// Signal existing thread.

signalThreads.Post();

}

}

Il2CppAsyncResult* ThreadPoolCompartment::DequeueNextWorkItem()

{

os::FastAutoLock lock(&mutex);

if (queue.empty())

return NULL;

Il2CppAsyncResult* result = queue.front();

queue.pop();

return result;

}

static void WorkerThreadEntryPoint(void* data);

void ThreadPoolCompartment::SpawnNewWorkerThread()

{

os::Thread* thread = new os::Thread();

thread->Run(WorkerThreadEntryPoint, this);

}

static void HandleSocketAsyncOperation(Il2CppAsyncResult* asyncResult)

}

void ThreadPoolCompartment::WorkerThreadRunLoop()

{

#if IL2CPP_TINY

IL2CPP_ASSERT(0 && "This function should never be called with the Tiny profile");

#else

bool waitingToTerminate = false;

// Pump AsyncResults until we're killed.

while (true)

{

// Grab next work item.

Il2CppAsyncResult* asyncResult = DequeueNextWorkItem();

if (!asyncResult)

{

// There's no work for us to do so decide what to do.

// If we've exceeded the normal number of threads for the pool (minThreads),

// wait around for a bit and then, if there is no work to do,

// terminate.

IL2CPP_ASSERT(minThreads >= 0);

if (threads.size() > static_cast<uint32_t>(minThreads))

{

if (waitingToTerminate)

{

// We've already waited so now is the time to go.

break;

}

waitingToTerminate = true;

}

// No item so wait for signal. We need to allow interruptions here as we don't yet

// have proper abort support and the runtime currently uses interruptions to get

// background threads to exit.

os::Atomic::Increment(&numIdleThreads);

if (waitingToTerminate)

signalThreads.Wait(kGracePeriodBeforeExtranenousWorkerThreadTerminates, true);

else

signalThreads.Wait(true);

os::Atomic::Decrement(&numIdleThreads);

// Try again.

continue;

}

waitingToTerminate = false;

// See if it's a socket async call and if so, do whatever I/O we need to

// do before invoking the delegate.

Il2CppDelegate* delegate = asyncResult->async_delegate;

const bool isSocketAsyncCall = IsSocketAsyncCall(delegate);

if (isSocketAsyncCall)

HandleSocketAsyncOperation(asyncResult);

// Invoke delegate.

Il2CppAsyncCall* asyncCall = asyncResult->object_data;

Il2CppException* exception = NULL;

uint32_t argsGCHandle = (uint32_t)((uintptr_t)asyncResult->data);

Il2CppArray* args = (Il2CppArray*)gc::GCHandle::GetTarget(argsGCHandle);

const uint8_t paramsCount = delegate->method->parameters_count;

uint8_t byRefArgsCount = 0;

for (uint8_t i = 0; i < paramsCount; ++i)

{

const Il2CppType* paramType = (Il2CppType*)delegate->method->parameters[i].parameter_type;

if (paramType->byref)

++byRefArgsCount;

}

void** byRefArgs = 0;

if (byRefArgsCount > 0)

{

IL2CPP_OBJECT_SETREF(asyncCall, out_args, vm::Array::New(il2cpp_defaults.object_class, byRefArgsCount));

byRefArgs = (void**)il2cpp_array_addr(asyncCall->out_args, Il2CppObject*, 0);

}

void** argsPtr = (void**)il2cpp_array_addr(args, Il2CppObject*, 0);

void** params = (void**)IL2CPP_MALLOC(paramsCount * sizeof(void*));

int byRefIndex = 0;

for (uint8_t i = 0; i < paramsCount; ++i)

{

Il2CppType* paramType = (Il2CppType*)delegate->method->parameters[i].parameter_type;

const Il2CppClass* paramClass = il2cpp_class_from_type(paramType);

const bool isValueType = il2cpp_class_is_valuetype(paramClass);

if (paramType->byref)

{

if (isValueType)

{

// Value types are always boxed

il2cpp_array_setref(asyncCall->out_args, byRefIndex, il2cpp_object_unbox((Il2CppObject*)argsPtr[i]));

params[i] = byRefArgs[byRefIndex++];

}

else

{

il2cpp_array_setref(asyncCall->out_args, byRefIndex, argsPtr[i]);

params[i] = &byRefArgs[byRefIndex++];

}

}

else

{

params[i] = isValueType

? il2cpp_object_unbox((Il2CppObject*)argsPtr[i]) // Value types are always boxed

: argsPtr[i];

}

}

Il2CppObject* result = il2cpp_runtime_invoke(delegate->method, delegate->target, params, &exception);

IL2CPP_FREE(params);

gc::GCHandle::Free(argsGCHandle);

// Store result.

IL2CPP_OBJECT_SETREF(asyncCall, res, result);

IL2CPP_OBJECT_SETREF(asyncCall, msg, (Il2CppMethodMessage*)exception);

os::Atomic::FullMemoryBarrier();

asyncResult->completed = true;

// Invoke callback, if we have one.

Il2CppDelegate* asyncCallback = asyncCall->cb_target;

if (asyncCallback)

{

void* args[1] = { asyncResult };

il2cpp_runtime_invoke(asyncCallback->method, asyncCallback->target, args, &exception);

IL2CPP_OBJECT_SETREF(asyncCall, msg, (Il2CppMethodMessage*)exception);

}

// Signal wait handle, if there's one.

il2cpp_monitor_enter(&asyncResult->base);

if (asyncResult->handle)

{

os::Handle* osHandle = vm::WaitHandle::GetPlatformHandle(asyncResult->handle);

osHandle->Signal();

}

il2cpp_monitor_exit(&asyncResult->base);

}

#endif

}

static void WorkerThreadEntryPoint(void* data)

}

void ThreadPool::Initialize()

{

NOT_SUPPORTED_IL2CPP(ThreadPool::Initialize, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

}

void ThreadPool::Shutdown()

{

NOT_SUPPORTED_IL2CPP(ThreadPool::Shutdown, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

}

ThreadPool::Configuration ThreadPool::GetConfiguration()

{

NOT_SUPPORTED_IL2CPP(ThreadPool::GetConfiguration, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

IL2CPP_UNREACHABLE;

return Configuration();

}

void ThreadPool::SetConfiguration(const Configuration& configuration)

{

NOT_SUPPORTED_IL2CPP(ThreadPool::SetConfiguration, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

}

Il2CppAsyncResult* ThreadPool::Queue(Il2CppDelegate* delegate, void** params, Il2CppDelegate* asyncCallback, Il2CppObject* state)

{

NOT_SUPPORTED_IL2CPP(ThreadPool::Queue, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

IL2CPP_UNREACHABLE;

return NULL;

}

Il2CppObject* ThreadPool::Wait(Il2CppAsyncResult* asyncResult, void** outArgs)

{

NOT_SUPPORTED_IL2CPP(ThreadPool::Wait, "vm::ThreadPool is not supported in .NET 4.5, use threadpool-ms instead");

IL2CPP_UNREACHABLE;

return NULL;

}

} /* namespace vm */

} /* namespace il2cpp */