Reduce allocation in NegotiateStream.Read/Write{Async}

[stephentoub]

1. Each time we call Write{Async}, we're allocating a new byte[] to store the encoded message to be written. Instead, just save the byte[] and reuse it, only allocating a new one if the existing one isn't big enough.
2. In both Read/Write{Async}, we call into an EncryptDecryptHelper (on Windows) that allocates a byte[][]. It never has more than three buffers. We can just stack allocate it.
3. In my previous change to switch to async/await, I used a default interface method. But when such a method is invoked on a struct implementing the interface, the struct gets boxed. Just move that instance off and avoid several allocations per read.

Method	Toolchain	Mean	Ratio	Gen 0	Allocated
WriteRead	netcore31	14.99 ms	1.00	93.7500	616001 B
WriteRead	master	13.24 ms	0.88	31.2500	200001 B
WriteRead	pr	12.82 ms	0.85	-	1 B
ReadWrite	netcore31	34.49 ms	1.00	71.4286	760230 B
ReadWrite	master	33.30 ms	0.97	62.5000	528230 B
ReadWrite	pr	32.76 ms	0.95	-	336240 B

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Threading.Tasks;

[MemoryDiagnoser]
public class Program
{
    static void Main(string[] args) => BenchmarkSwitcher.FromAssemblies(new[] { typeof(Program).Assembly }).Run(args);

    private Stream _client, _server;

    [GlobalSetup]
    public void ReadWriteSetup()
    {
        using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
        {
            listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
            listener.Listen(1);

            var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            client.Connect(listener.LocalEndPoint);
            var server = listener.Accept();
            var clientStream = new NegotiateStream(new NetworkStream(client, ownsSocket: true), leaveInnerStreamOpen: true);
            var serverStream = new NegotiateStream(new NetworkStream(server, ownsSocket: true), leaveInnerStreamOpen: true);

            Task ca = clientStream.AuthenticateAsClientAsync();
            Task sa = serverStream.AuthenticateAsServerAsync();
            Task.WaitAll(ca, sa);

            _client = clientStream;
            _server = serverStream;
        }
    }

    private byte[] _oneByteBuffer = new byte[1];

    [Benchmark]
    public async Task WriteRead()
    {
        for (int i = 0; i < 1_000; i++)
        {
            await _server.WriteAsync(_oneByteBuffer);
            await _client.ReadAsync(_oneByteBuffer);
        }
    }

    [Benchmark]
    public async Task ReadWrite()
    {
        for (int i = 0; i < 1_000; i++)
        {
            var r = _client.ReadAsync(_oneByteBuffer);
            await _server.WriteAsync(_oneByteBuffer);
            await r;
        }
    }
}

[ghost]

Tagging subscribers to this area: @dotnet/ncl
Notify danmosemsft if you want to be subscribed.

[stephentoub]

cc: @davidsh, @brianrob

[wfurt]

LGTM.
This is essentially what we do in SslStream, right?

[stephentoub]

Yup