Resuse write requests

Is only one per write context

Author: benaadams

src/Microsoft.AspNet.Server.Kestrel/Http/SocketOutput.cs

@@ -25,6 +25,7 @@ public class SocketOutput : ISocketOutput
 
         // This locks access to to all of the below fields
         private readonly object _lockObj = new object();
+        private bool _isDisposed;
 
         // The number of write operations that have been scheduled so far
         // but have not completed.
@@ -236,11 +237,16 @@ private void OnWriteCompleted(WriteContext write)
                 }
 
                 if (_writeContexts.Count < _maxPooledWriteContexts 
-                    && write.Buffers.Count <= _maxPooledBufferQueues)
+                    && write.Buffers.Count <= _maxPooledBufferQueues
+                    && !_isDisposed)
                 {
                     write.Reset();
                     _writeContexts.Enqueue(write);
                 }
+                else
+                {
+                    write.Dispose();
+                }
 
                 // Now that the while loop has completed the following invariants should hold true:
                 Debug.Assert(_numBytesPreCompleted >= 0);
@@ -268,7 +274,21 @@ Task ISocketOutput.WriteAsync(ArraySegment<byte> buffer, bool immediate, Cancell
             return WriteAsync(buffer, immediate);
         }
 
-        private class WriteContext
+        private void Dispose()
+        {
+            lock (_lockObj)
+            {
+                _isDisposed = true;
+
+                while (_writeContexts.Count > 0)
+                {
+                    _writeContexts.Dequeue().Dispose();
+                }
+            }
+
+        }
+
+        private class WriteContext : IDisposable
         {
             public SocketOutput Self;
 
@@ -278,13 +298,16 @@ private class WriteContext
 
             public int WriteStatus;
             public Exception WriteError;
+            private UvWriteReq _writeReq;
 
             public int ShutdownSendStatus;
 
             public WriteContext(SocketOutput self)
             {
                 Self = self;
                 Buffers = new Queue<ArraySegment<byte>>(_maxPooledBufferQueues);
+                _writeReq = new UvWriteReq(Self._log);
+                _writeReq.Init(Self._thread.Loop);
             }
 
             /// <summary>
@@ -305,12 +328,9 @@ public void DoWriteIfNeeded()
                 {
                     buffers[i++] = buffer;
                 }
-
-                var writeReq = new UvWriteReq(Self._log);
-                writeReq.Init(Self._thread.Loop);
-                writeReq.Write(Self._socket, new ArraySegment<ArraySegment<byte>>(buffers), (_writeReq, status, error, state) =>
+                
+                _writeReq.Write(Self._socket, new ArraySegment<ArraySegment<byte>>(buffers), (_writeReq, status, error, state) =>
                 {
-                    _writeReq.Dispose();
                     var _this = (WriteContext)state;
                     _this.WriteStatus = status;
                     _this.WriteError = error;
@@ -348,11 +368,17 @@ public void DoShutdownIfNeeded()
             /// </summary>
             public void DoDisconnectIfNeeded()
             {
-                if (SocketDisconnect == false || Self._socket.IsClosed)
+                if (SocketDisconnect == false)
                 {
                     Complete();
                     return;
                 }
+                else if (Self._socket.IsClosed)
+                {
+                    Self.Dispose();
+                    Complete();
+                    return;
+                }
 
                 Self._socket.Dispose();
                 Self._log.ConnectionStop(Self._connectionId);
@@ -373,6 +399,11 @@ public void Reset()
                 WriteError = null;
                 ShutdownSendStatus = 0;
             }
+
+            public void Dispose()
+            {
+                _writeReq.Dispose();
+            }
         }
     }
 }