DotNetty发送请求的最佳实践

长链接发送request/response时, 绝大部分包都是小包, 而每个小包都要消耗一个IP包, 成本大约是20-30us, 普通千兆网卡的pps大约是60Wpps, 所以想要提高长链接密集IO的应用性能, 需要做包的合并, 也称为了scatter/gather io或者vector io.

在linux下有readv/writev就是对应这个需求的, 减少系统调用, 减少pps, 提高网卡的吞吐量. 关于readv提高读的速度, 可以看看陈硕muduo里面对于readv的使用, 思路是就是在栈上面弄一个64KB的数组, 组成readv的第二块buffer, 从而尽可能一次性把socket缓冲区的内容全部出来(参见5). 这里不再赘述, 重点描述DotNetty下面怎么做Gathering Write.

首先得有一个Channel<IMessage>, 用来做写的缓冲, 让业务关心业务, 网络关心网络, 否则每个业务都WriteAndFlushAsync, 那是不太可能有合并发送的.

然后就是SendingLoop的主循环, 里面不停的从Channel里面TryRead包, 然后WriteAsync, 隔几个包Flush一次. 类似的思想在Orleans Network里面也存在.

 public void RunSendLoopAsync(IChannel channel)
 {
     var allocator = channel.Allocator;
     var reader = this.queue.Reader;
     Task.Run(async () =>
     {
         while (!this.stop)
         {
             var more = await reader.WaitToReadAsync();
             if (!more)
             {
                 break;
             }

             IOutboundMessage message = default;
             var number = ;
             try
             {
                 while (number <  && reader.TryRead(out message) && message != null)
                 {
                     Interlocked.Decrement(ref this.queueCount);
                     var msg = message.Inner as IMessage;
                     var buffer = msg.ToByteBuffer(allocator);
                     channel.WriteAsync(buffer);
                     number++;
                 }
                 channel.Flush();
                 number = ;
             }
             catch (Exception e)  when(message != default)
             {
                 logger.LogError("SendOutboundMessage Fail, SessionID:{0}, Exception:{1}",
                     this.sessionID, e.Message);
                 this.messageCenter.OnMessageFail(message);
             }
         }
         this.logger.LogInformation("SessionID:{0}, SendingLoop Exit", this.sessionID);
     });
 }

第19-27行是关键, 这边每4个包做一下flush, 然后flush会触发DotNetty的DoWrite:

 protected override void DoWrite(ChannelOutboundBuffer input)
 {
     List<ArraySegment<byte>> sharedBufferList = null;
     try
     {
         while (true)
         {
             int size = input.Size;
             if (size == )
             {
                 // All written
                 break;
             }
             long writtenBytes = ;
             bool done = false;

             // Ensure the pending writes are made of ByteBufs only.
             int maxBytesPerGatheringWrite = ((TcpSocketChannelConfig)this.config).GetMaxBytesPerGatheringWrite();
             sharedBufferList = input.GetSharedBufferList(, maxBytesPerGatheringWrite);
             int nioBufferCnt = sharedBufferList.Count;
             long expectedWrittenBytes = input.NioBufferSize;
             Socket socket = this.Socket;

             List<ArraySegment<byte>> bufferList = sharedBufferList;
             // Always us nioBuffers() to workaround data-corruption.
             // See https://github.com/netty/netty/issues/2761
             switch (nioBufferCnt)
             {
                 case :
                     // We have something else beside ByteBuffers to write so fallback to normal writes.
                     base.DoWrite(input);
                     return;
                 default:
                     for (int i = this.Configuration.WriteSpinCount - ; i >= ; i--)
                     {
                         long localWrittenBytes = socket.Send(bufferList, SocketFlags.None, out SocketError errorCode);
                         if (errorCode != SocketError.Success && errorCode != SocketError.WouldBlock)
                         {
                             throw new SocketException((int)errorCode);
                         }

DotNetty TcpSocketChannel类的DoWrite函数, 19行获取当前ChannelOutboundBuffer的Segment<byte>数组, 然后在36行调用Socket.Send一次性发出去, 这个是Gathering Write的关键. 有了这个, 就可以不在业务层用CompositeByteBuffer.

DotNetty Libuv Transport的实现可以看6, 思想是类似的.

实际上Orleans 3.x做的网络优化, 也有类似的思想:

 private async Task ProcessOutgoing()
 {
     await Task.Yield();

     Exception error = default;
     PipeWriter output = default;
     var serializer = this.serviceProvider.GetRequiredService<IMessageSerializer>();
     try
     {
         output = this.Context.Transport.Output;
         var reader = this.outgoingMessages.Reader;
         if (this.Log.IsEnabled(LogLevel.Information))
         {
             this.Log.LogInformation(
                 "Starting to process messages from local endpoint {Local} to remote endpoint {Remote}",
                 this.LocalEndPoint,
                 this.RemoteEndPoint);
         }

         while (true)
         {
             var more = await reader.WaitToReadAsync();
             if (!more)
             {
                 break;
             }

             Message message = default;
             try
             {
                 while (inflight.Count < inflight.Capacity && reader.TryRead(out message) && this.PrepareMessageForSend(message))
                 {
                     inflight.Add(message);
                     var (headerLength, bodyLength) = serializer.Write(ref output, message);
                     MessagingStatisticsGroup.OnMessageSend(this.MessageSentCounter, message, headerLength + bodyLength, headerLength, this.ConnectionDirection);
                 }
             }
             catch (Exception exception) when (message != default)
             {
                 this.OnMessageSerializationFailure(message, exception);
             }

             var flushResult = await output.FlushAsync();
             if (flushResult.IsCompleted || flushResult.IsCanceled)
             {
                 break;
             }

             inflight.Clear();
         }

核心在31行, 开始写, 43行开始flush, 只不过Orleans用的pipelines io, DotNetty是传统模型.

这样做, 可以在有限的pps下, 支撑更高的吞吐量.

个人感觉DotNetty更好用一些.

参考:

1. https://github.com/Azure/DotNetty/blob/dev/src/DotNetty.Transport/Channels/Sockets/TcpSocketChannel.cs#L271-L288

2. https://github.com/dotnet/orleans/blob/master/src/Orleans.Core/Networking/Connection.cs#L282-L294

3. https://docs.microsoft.com/zh-cn/windows/win32/winsock/scatter-gather-i-o-2

4. https://linux.die.net/man/2/writev

5. https://github.com/chenshuo/muduo/blob/d980315dc054b122612f423ee2e1316cb14bd3b5/muduo/net/Buffer.cc#L28-L38

6. https://github.com/Azure/DotNetty/blob/dev/src/DotNetty.Transport.Libuv/Native/WriteRequest.cs#L106-L128