public static ValueTask <IConnectionListener> Create(EndPoint endpoint, IoUringTransport transport)
{
var listener = new ConnectionListener(endpoint, transport);
listener.Bind();
return(new ValueTask <IConnectionListener>(listener));
}
public async void SmokeTest(Func <EndPoint> endpoint, int length, PipeScheduler schedulerMode, int threadCount, int ringSize, bool threadAffinity)
{
using var server = new EchoServer(endpoint(), OutputHelper);
await using var transport = new IoUringTransport(Options.Create(new IoUringOptions
{
ThreadCount = threadCount,
SetThreadAffinity = threadAffinity,
ApplicationSchedulingMode = schedulerMode,
RingSize = ringSize
}));
await using var connectionFactory = new ConnectionFactory(transport);
for (int i = 0; i < 3; i++)
{
await using var connection = await connectionFactory.ConnectAsync(server.EndPoint);
for (int j = 0; j < 3; j++)
{
await SendReceiveData(connection.Transport, length);
}
await connection.Transport.Output.CompleteAsync();
await connection.Transport.Input.CompleteAsync();
}
}
private ConnectionListener(EndPoint endpoint, IoUringTransport transport, IoUringOptions options)
{
_transport = transport;
_options = options;
_acceptQueue = Channel.CreateUnbounded <ConnectionContext>(new UnboundedChannelOptions
{
SingleReader = true, // reads happen sequentially
SingleWriter = false,
AllowSynchronousContinuations = options.ApplicationSchedulingMode == PipeScheduler.Inline
});
EndPoint = endpoint;
}
public async Task SmokeTest(Func <EndPoint> endPoint, int length, PipeScheduler schedulerMode, int threadCount, int ringSize, bool threadAffinity)
{
var options = Options.Create(new IoUringOptions
{
ThreadCount = threadCount,
SetThreadAffinity = threadAffinity,
ApplicationSchedulingMode = schedulerMode,
RingSize = ringSize
});
await using var transport = new IoUringTransport(options);
var listenerFactory = new ConnectionListenerFactory(transport, options);
await using (var listener = await listenerFactory.BindAsync(endPoint()))
{
for (int i = 0; i < 3; i++)
{
var client = new EchoClient(listener.EndPoint);
await using (var connection = await listener.AcceptAsync())
{
for (int j = 0; j < 3; j++)
{
var exchange = client.ExchangeData(length);
await LoopBack(connection.Transport, length);
await exchange;
}
await connection.Transport.Output.CompleteAsync();
await connection.Transport.Input.CompleteAsync();
}
client.Close();
}
}
}
public ConnectionFactory(IoUringTransport transport)
{
_transport = transport;
_transport.IncrementThreadRefCount();
}
private int _threadIndex = -1; // -1 so we start at 0 at first Increment
public ConnectionFactory(IoUringTransport transport)
{
_transport = transport;
}
public ConnectionListenerFactory(IoUringTransport ioUringTransport, IOptions <IoUringOptions> options)
{
_ioUringTransport = ioUringTransport;
_options = options.Value;
}
private ConnectionListener(EndPoint endpoint, IoUringTransport transport)
{
EndPoint = endpoint;
_transport = transport;
}
public ConnectionListenerFactory(IoUringTransport ioUringTransport)
{
_ioUringTransport = ioUringTransport;
}
public static async ValueTask <IConnectionListener> BindAsync(EndPoint endpoint, IoUringTransport transport, IoUringOptions options)
{
var listener = new ConnectionListener(endpoint, transport, options);
await listener.BindAsync();
return(listener);
}
private ConnectionListener(EndPoint endpoint, IoUringTransport transport, IoUringOptions options)
{
EndPoint = endpoint;
_transport = transport;
_options = options;
}
