private unsafe void AcceptThreadStart(object state)
{
try
{
var socket = _socket;
using (socket)
{
using (EPoll epoll = EPoll.Create())
{
int epollFd = epoll.DangerousGetHandle().ToInt32();
const int acceptKey = 0;
const int pipeKey = 1;
// accept socket
epoll.Control(EPollOperation.Add, _socket, EPollEvents.Readable, new EPollData {
Int1 = acceptKey, Int2 = acceptKey
});
// add pipe
epoll.Control(EPollOperation.Add, _pipeEnds.ReadEnd, EPollEvents.Readable, new EPollData {
Int1 = pipeKey, Int2 = pipeKey
});
const int EventBufferLength = 1;
int notPacked = !EPoll.PackedEvents ? 1 : 0;
var buffer = stackalloc int[EventBufferLength * (3 + notPacked)];
int * key = &buffer[2];
bool running = true;
int nextHandler = 0;
var handlers = _handlers;
do
{
int numEvents = EPollInterop.EPollWait(epollFd, buffer, EventBufferLength, timeout: EPoll.TimeoutInfinite).Value;
if (numEvents == 1)
{
if (*key == acceptKey)
{
var handler = handlers[nextHandler];
nextHandler = (nextHandler + 1) % handlers.Length;
socket.TryAcceptAndSendHandleTo(handler);
}
else
{
running = false;
}
}
} while (running);
}
}
_stoppedTcs.TrySetResult(null);
}
catch (Exception e)
{
_stoppedTcs.SetException(e);
}
finally
{
Cleanup();
}
}
private unsafe void PollThread(object obj)
{
ThreadContext threadContext = null;
Exception error = null;
try
{
// .NET doesn't support setting thread affinity on Start
// We could change it before starting the thread
// so it gets inherited, but we don't know how many threads
// the runtime may start.
if (_cpuId != -1)
{
Scheduler.SetCurrentThreadAffinity(_cpuId);
}
// objects are allocated on the PollThread heap
int pipeKey;
threadContext = new ThreadContext(this, _transportOptions, _connectionHandler, CreateLogger());
threadContext.Initialize();
{
// register pipe
pipeKey = threadContext.PipeEnds.ReadEnd.DangerousGetHandle().ToInt32();
EPollInterop.EPollControl(threadContext.EPollFd,
EPollOperation.Add,
threadContext.PipeEnds.ReadEnd.DangerousGetHandle().ToInt32(),
EPollEvents.Readable,
EPollData(pipeKey));
// accept connections
AcceptOn(_endPoint, _cpuId, _transportOptions, threadContext);
_threadContext = threadContext;
}
int epollFd = threadContext.EPollFd;
var readEnd = threadContext.PipeEnds.ReadEnd;
int notPacked = !EPoll.PackedEvents ? 1 : 0;
var buffer = stackalloc int[EventBufferLength * (3 + notPacked)];
int statReadEvents = 0;
int statWriteEvents = 0;
int statAcceptEvents = 0;
int statAccepts = 0;
var sockets = threadContext.Sockets;
var acceptableSockets = new List <TSocket>(1);
var readableSockets = new List <TSocket>(EventBufferLength);
var writableSockets = new List <TSocket>(EventBufferLength);
bool pipeReadable = false;
CompleteStateChange(State.Started);
bool running = true;
do
{
int numEvents = EPollInterop.EPollWait(epollFd, buffer, EventBufferLength, timeout: EPoll.TimeoutInfinite).Value;
// actions can be scheduled without unblocking epoll
threadContext.SetEpollNotBlocked();
// check events
// we don't handle them immediately:
// - this ensures we don't mismatch a closed socket with a new socket that have the same fd
// ~ To have the same fd, the previous fd must be closed, which means it is removed from the epoll
// ~ and won't show up in our next call to epoll.Wait.
// ~ The old fd may be present in the buffer still, but lookup won't give a match, since it is removed
// ~ from the dictionary before it is closed. If we were accepting already, a new socket could match.
// - this also improves cache/cpu locality of the lookup
int *ptr = buffer;
lock (sockets)
{
for (int i = 0; i < numEvents; i++)
{
// Packed Non-Packed
// ------ ------
// 0:Events == Events
// 1:Int1 = Key [Padding]
// 2:Int2 = Key == Int1 = Key
// 3:~~~~~~~~~~ Int2 = Key
// ~~~~~~~~~~
int key = ptr[2];
ptr += 3 + notPacked;
TSocket tsocket;
if (sockets.TryGetValue(key & ~DupKeyMask, out tsocket))
{
var type = tsocket.Flags & SocketFlags.TypeMask;
if (type == SocketFlags.TypeClient)
{
bool read = (key & DupKeyMask) == 0;
if (read)
{
readableSockets.Add(tsocket);
}
else
{
writableSockets.Add(tsocket);
}
}
else
{
statAcceptEvents++;
acceptableSockets.Add(tsocket);
}
}
else if (key == pipeKey)
{
pipeReadable = true;
}
}
}
// handle accepts
statAcceptEvents += acceptableSockets.Count;
for (int i = 0; i < acceptableSockets.Count; i++)
{
statAccepts += HandleAccept(acceptableSockets[i], threadContext);
}
acceptableSockets.Clear();
// handle writes
statWriteEvents += writableSockets.Count;
for (int i = 0; i < writableSockets.Count; i++)
{
writableSockets[i].CompleteWritable();
}
writableSockets.Clear();
// handle reads
statReadEvents += readableSockets.Count;
for (int i = 0; i < readableSockets.Count; i++)
{
readableSockets[i].CompleteReadable();
}
readableSockets.Clear();
// handle pipe
if (pipeReadable)
{
PosixResult result;
do
{
result = readEnd.TryReadByte();
if (result.Value == PipeStopSockets)
{
StopSockets(threadContext.Sockets);
}
else if (result.Value == PipeStopThread)
{
running = false;
}
} while (result);
pipeReadable = false;
}
// scheduled work
threadContext.DoScheduledWork();
} while (running);
threadContext.Logger.LogInformation($"Thread {_threadId}: Stats A/AE:{statAccepts}/{statAcceptEvents} RE:{statReadEvents} WE:{statWriteEvents}");
}
catch (Exception ex)
{
error = ex;
}
finally
{
// We are not using SafeHandles for epoll to increase performance.
// running == false when there are no more Sockets
// so we are sure there are no more epoll users.
threadContext?.Dispose();
CompleteStateChange(State.Stopped, error);
}
}
public unsafe PosixResult TryWait(void *events, int maxEvents, int timeout)
{
return(EPollInterop.EPollWait(this, events, maxEvents, timeout));
}
public unsafe void Run()
{
try
{
Start();
CompleteStateChange(TransportThreadState.Started);
}
catch (Exception e)
{
CompleteStateChange(TransportThreadState.Stopped, e);
return;
}
try
{
int notPacked = !EPoll.PackedEvents ? 1 : 0;
var buffer = stackalloc int[EventBufferLength * (3 + notPacked)];
int statReadEvents = 0;
int statWriteEvents = 0;
int statAcceptEvents = 0;
int statAccepts = 0;
int statZeroCopySuccess = 0;
int statZeroCopyCopied = 0;
var acceptableSockets = new List <TSocket>(1);
var readableSockets = new List <TSocket>(EventBufferLength);
var writableSockets = new List <TSocket>(EventBufferLength);
var reregisterEventSockets = new List <TSocket>(EventBufferLength);
var zeroCopyCompletions = new List <TSocket>(EventBufferLength);
bool pipeReadable = false;
bool running = true;
do
{
int numEvents = EPollInterop.EPollWait(_epollFd, buffer, EventBufferLength, timeout: EPoll.TimeoutInfinite).Value;
// actions can be scheduled without unblocking epoll
SetEpollNotBlocked();
// check events
// we don't handle them immediately:
// - this ensures we don't mismatch a closed socket with a new socket that have the same fd
// ~ To have the same fd, the previous fd must be closed, which means it is removed from the epoll
// ~ and won't show up in our next call to epoll.Wait.
// ~ The old fd may be present in the buffer still, but lookup won't give a match, since it is removed
// ~ from the dictionary before it is closed. If we were accepting already, a new socket could match.
// - this also improves cache/cpu locality of the lookup
int *ptr = buffer;
lock (_sockets)
{
for (int i = 0; i < numEvents; i++)
{
// Packed Non-Packed
// ------ ------
// 0:Events == Events
// 1:Int1 = Key [Padding]
// 2:Int2 = Key == Int1 = Key
// 3:~~~~~~~~~~ Int2 = Key
// ~~~~~~~~~~
EPollEvents events = (EPollEvents)ptr[0];
int key = ptr[2];
ptr += 3 + notPacked;
TSocket tsocket;
if (_sockets.TryGetValue(key, out tsocket))
{
var type = tsocket.Type;
if (type == SocketFlags.TypeClient)
{
lock (tsocket.Gate)
{
var pendingEventState = tsocket.PendingEventState;
// zero copy
if ((pendingEventState & EPollEvents.Error & events) != EPollEvents.None)
{
var copyResult = SocketInterop.CompleteZeroCopy(tsocket.Fd);
if (copyResult != PosixResult.EAGAIN)
{
events &= ~EPollEvents.Error;
pendingEventState &= ~EPollEvents.Error;
zeroCopyCompletions.Add(tsocket);
if (copyResult == SocketInterop.ZeroCopyCopied)
{
tsocket.ZeroCopyThreshold = LinuxTransportOptions.NoZeroCopy;
statZeroCopyCopied++;
}
else if (copyResult == SocketInterop.ZeroCopySuccess)
{
statZeroCopySuccess++;
}
else
{
Environment.FailFast($"Error occurred while trying to complete zero copy: {copyResult}");
}
}
}
// treat Error as Readable, Writable
if ((events & EPollEvents.Error) != EPollEvents.None)
{
events |= EPollEvents.Readable | EPollEvents.Writable;
}
events &= pendingEventState & (EPollEvents.Readable | EPollEvents.Writable);
// readable
if ((events & EPollEvents.Readable) != EPollEvents.None)
{
readableSockets.Add(tsocket);
pendingEventState &= ~EPollEvents.Readable;
}
// writable
if ((events & EPollEvents.Writable) != EPollEvents.None)
{
writableSockets.Add(tsocket);
pendingEventState &= ~EPollEvents.Writable;
}
// reregister
tsocket.PendingEventState = pendingEventState;
if ((pendingEventState & (EPollEvents.Readable | EPollEvents.Writable)) != EPollEvents.None)
{
tsocket.PendingEventState |= TSocket.EventControlPending;
reregisterEventSockets.Add(tsocket);
}
}
}
else
{
statAcceptEvents++;
acceptableSockets.Add(tsocket);
}
}
else if (key == PipeKey)
{
pipeReadable = true;
}
}
}
// zero copy
for (int i = 0; i < zeroCopyCompletions.Count; i++)
{
zeroCopyCompletions[i].OnZeroCopyCompleted();
}
zeroCopyCompletions.Clear();
// handle accepts
statAcceptEvents += acceptableSockets.Count;
for (int i = 0; i < acceptableSockets.Count; i++)
{
statAccepts += HandleAccept(acceptableSockets[i]);
}
acceptableSockets.Clear();
// handle writes
statWriteEvents += writableSockets.Count;
for (int i = 0; i < writableSockets.Count; i++)
{
writableSockets[i].OnWritable(stopped: false);
}
writableSockets.Clear();
// handle reads
statReadEvents += readableSockets.Count;
if (!_transportOptions.AioReceive)
{
bool checkAvailable = _transportOptions.CheckAvailable;
Span <MemoryHandle> receiveMemoryHandles = MemoryHandles;
for (int i = 0; i < readableSockets.Count; i++)
{
TSocket socket = readableSockets[i];
int availableBytes = !checkAvailable ? 0 : socket.GetAvailableBytes();
var receiveResult = socket.Receive(availableBytes, receiveMemoryHandles);
socket.OnReceiveFromSocket(receiveResult);
}
readableSockets.Clear();
}
else if (readableSockets.Count > 0)
{
AioReceive(readableSockets);
}
// reregister for events
for (int i = 0; i < reregisterEventSockets.Count; i++)
{
var tsocket = reregisterEventSockets[i];
lock (tsocket.Gate)
{
var pendingEventState = tsocket.PendingEventState & ~TSocket.EventControlPending;
tsocket.PendingEventState = pendingEventState;
UpdateEPollControl(tsocket, pendingEventState, registered: true);
}
}
reregisterEventSockets.Clear();
// handle pipe
if (pipeReadable)
{
PosixResult result;
do
{
result = _pipeEnds.ReadEnd.TryReadByte();
if (result.Value == PipeStopSockets)
{
StopSockets();
}
else if (result.Value == PipeStopThread)
{
running = false;
}
else if (result.Value == PipeCloseAccept)
{
CloseAccept();
}
} while (result);
pipeReadable = false;
}
// scheduled work
// note: this may write a byte to the pipe
DoScheduledWork(_transportOptions.AioSend);
} while (running);
_logger.LogDebug($"Stats A/AE:{statAccepts}/{statAcceptEvents} RE:{statReadEvents} WE:{statWriteEvents} ZCS/ZCC:{statZeroCopySuccess}/{statZeroCopyCopied}");
CompleteStateChange(TransportThreadState.Stopped);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Environment.FailFast("TransportThread", ex);
}
}
