remove the concept of the unsent queue; the pipeline **is** that queue - no...

remove the concept of the unsent queue; the pipeline **is** that queue - no need to duplicate (and significantly simplifies); if you've successfully pushed a message to the bridge: *it is in the pipe*; also removes "ar", "wr", "wq", "qu" and "pending" counters

StackExchange.Redis/StackExchange/Redis/ConnectionMultiplexer.ReaderWriter.cs

@@ -18,18 +18,6 @@ public partial class ConnectionMultiplexer
             if (ownsSocketManager) socketManager?.Dispose();
             socketManager = null;
         }
-
-        internal void RequestWrite(PhysicalBridge bridge, bool forced)
-        {
-            if (bridge == null) return;
-            var tmp = SocketManager;
-            if (tmp != null)
-            {
-                Trace("Requesting write: " + bridge.Name);
-                tmp.RequestWrite(bridge, forced);
-            }
-        }
-
         partial void OnWriterCreated();
     }
 }

StackExchange.Redis/StackExchange/Redis/ConnectionMultiplexer.cs

@@ -2007,10 +2007,6 @@ internal T ExecuteSyncImpl<T>(Message message, ResultProcessor<T> processor, Ser
                         }
                         else
                         {
-#if FEATURE_SOCKET_MODE_POLL
-                            var mgrState = socketManager.State;
-                            var lastError = socketManager.LastErrorTimeRelative();
-#endif
                             var sb = new StringBuilder("Timeout performing ").Append(message.CommandAndKey);
                             data = new List<Tuple<string, string>> { Tuple.Create("Message", message.CommandAndKey) };
                             void add(string lk, string sk, string v)
@@ -2019,20 +2015,12 @@ void add(string lk, string sk, string v)
                                 sb.Append(", ").Append(sk).Append(": ").Append(v);
                             }
 
-                            int queue = server.GetOutstandingCount(message.Command, out int inst, out int qu, out int qs, out int qc, out int wr, out int wq, out int @in, out int ar);
+                            int queue = server.GetOutstandingCount(message.Command, out int inst, out int qs, out int qc, out int @in);
                             add("Instantaneous", "inst", inst.ToString());
-#if FEATURE_SOCKET_MODE_POLL
-                            add("Manager-State", "mgr", mgrState.ToString());
-                            add("Last-Error", "err", lastError);
-#endif
                             add("Queue-Length", "queue", queue.ToString());
-                            add("Queue-Outstanding", "qu", qu.ToString());
                             add("Queue-Awaiting-Response", "qs", qs.ToString());
                             add("Queue-Completion-Outstanding", "qc", qc.ToString());
-                            add("Active-Writers", "wr", wr.ToString());
-                            add("Write-Queue", "wq", wq.ToString());
                             add("Inbound-Bytes", "in", @in.ToString());
-                            add("Active-Readers", "ar", ar.ToString());
 
                             add("Client-Name", "clientName", ClientName);
                             add("Server-Endpoint", "serverEndpoint", server.EndPoint.ToString());

StackExchange.Redis/StackExchange/Redis/DebuggingAids.cs

@@ -17,12 +17,6 @@ internal partial class ResultBox
 
     public partial interface IServer
     {
-        /// <summary>
-        /// Show what is in the pending (unsent) queue
-        /// </summary>
-        /// <param name="maxCount">The maximum count to list.</param>
-        string ListPending(int maxCount);
-
         /// <summary>
         /// Get the value of key. If the key does not exist the special value nil is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.
         /// </summary>
@@ -114,21 +108,11 @@ internal void SimulateConnectionFailure()
             interactive?.SimulateConnectionFailure();
             subscription?.SimulateConnectionFailure();
         }
-
-        internal string ListPending(int maxCount)
-        {
-            var sb = new StringBuilder();
-            interactive?.ListPending(sb, maxCount);
-            subscription?.ListPending(sb, maxCount);
-            return sb.ToString();
-        }
     }
 
     internal partial class RedisServer
     {
         void IServer.SimulateConnectionFailure() => server.SimulateConnectionFailure();
-        string IServer.ListPending(int maxCount) => server.ListPending(maxCount);
-
         void IServer.Crash()
         {
             // using DB-0 because we also use "DEBUG OBJECT", which is db-centric
@@ -225,11 +209,6 @@ internal void SimulateConnectionFailure()
             }
             physical?.RecordConnectionFailed(ConnectionFailureType.SocketFailure);
         }
-
-        internal void ListPending(StringBuilder sb, int maxCount)
-        {
-            queue.ListPending(sb, maxCount);
-        }
     }
 
     internal partial class PhysicalConnection

StackExchange.Redis/StackExchange/Redis/PhysicalBridge.cs

@@ -22,8 +22,6 @@ internal sealed partial class PhysicalBridge : IDisposable
     {
         internal readonly string Name;
 
-        internal int inWriteQueue = 0;
-
         private const int ProfileLogSamples = 10;
 
         private const double ProfileLogSeconds = (ConnectionMultiplexer.MillisecondsPerHeartbeat * ProfileLogSamples) / 1000.0;
@@ -32,7 +30,9 @@ internal sealed partial class PhysicalBridge : IDisposable
 
         private readonly CompletionManager completionManager;
         private readonly long[] profileLog = new long[ProfileLogSamples];
-        private readonly MessageQueue queue = new MessageQueue();
+
+        private readonly Queue<Message> _preconnectBacklog = new Queue<Message>();
+
         private int activeWriters = 0;
         private int beating;
         private int failConnectCount = 0;
@@ -123,7 +123,11 @@ public bool TryEnqueue(Message message, bool isSlave)
                 {
                     // you can go in the queue, but we won't be starting
                     // a worker, because the handshake has not completed
-                    queue.Push(message);
+                    var queue = _preconnectBacklog;
+                    lock(queue)
+                    {
+                        queue.Enqueue(message);
+                    }
                     message.SetEnqueued();
                     return true;
                 }
@@ -134,15 +138,13 @@ public bool TryEnqueue(Message message, bool isSlave)
                 }
             }
 
-            bool reqWrite = queue.Push(message);
-            message.SetEnqueued();
+            var physical = this.physical;
+            if (physical == null) return false;
+
+
+            WriteMessageDirect(physical, message);
             LogNonPreferred(message.Flags, isSlave);
-            Trace("Now pending: " + GetPendingCount());
 
-            if (reqWrite)
-            {
-                Multiplexer.RequestWrite(this, false);
-            }
             return true;
         }
 
@@ -171,22 +173,8 @@ internal void AppendProfile(StringBuilder sb)
             sb.Append(" (").Append(rate.ToString("N2")).Append(" ops/s; spans ").Append(ProfileLogSeconds).Append("s)");
         }
 
-        internal bool ConfirmRemoveFromWriteQueue()
-        {
-            lock (queue.SyncLock)
-            {
-                if (queue.Count() == 0)
-                {
-                    Interlocked.Exchange(ref inWriteQueue, 0);
-                    return true;
-                }
-            }
-            return false;
-        }
-
         internal void GetCounters(ConnectionCounters counters)
         {
-            counters.PendingUnsentItems = queue.Count();
             counters.OperationCount = OperationCount;
             counters.SocketCount = Interlocked.Read(ref socketCount);
             counters.WriterCount = Interlocked.CompareExchange(ref activeWriters, 0, 0);
@@ -195,28 +183,20 @@ internal void GetCounters(ConnectionCounters counters)
             physical?.GetCounters(counters);
         }
 
-        internal int GetOutstandingCount(out int inst, out int qu, out int qs, out int qc, out int wr, out int wq, out int @in, out int ar)
+        internal int GetOutstandingCount(out int inst, out int qs, out int qc, out int @in)
         {// defined as: PendingUnsentItems + SentItemsAwaitingResponse + ResponsesAwaitingAsyncCompletion
             inst = (int)(Interlocked.Read(ref operationCount) - Interlocked.Read(ref profileLastLog));
-            qu = queue.Count();
             var tmp = physical;
             if(tmp == null)
             {
-                qs = @in = ar = 0;
+                qs = @in = 0;
             } else
             {
                 qs = tmp.GetSentAwaitingResponseCount();
-                @in = tmp.GetAvailableInboundBytes(out ar);
+                @in = tmp.GetAvailableInboundBytes();
             }
             qc = completionManager.GetOutstandingCount();
-            wr = Interlocked.CompareExchange(ref activeWriters, 0, 0);
-            wq = Interlocked.CompareExchange(ref inWriteQueue, 0, 0);
-            return qu + qs + qc;
-        }
-
-        internal int GetPendingCount()
-        {
-            return queue.Count();
+            return qs + qc;
         }
 
         internal string GetStormLog()
@@ -224,7 +204,6 @@ internal string GetStormLog()
             var sb = new StringBuilder("Storm log for ").Append(Format.ToString(ServerEndPoint.EndPoint)).Append(" / ").Append(ConnectionType)
                 .Append(" at ").Append(DateTime.UtcNow)
                 .AppendLine().AppendLine();
-            queue.GetStormLog(sb);
             physical?.GetStormLog(sb);
             completionManager.GetStormLog(sb);
             sb.Append("Circular op-count snapshot:");
@@ -309,14 +288,6 @@ internal void OnDisconnected(ConnectionFailureType failureType, PhysicalConnecti
         {
             Trace("OnDisconnected");
 
-            // if the next thing in the pipe is a PING, we can tell it that we failed (this really helps spot doomed connects)
-            var ping = queue.DequeueUnsentPing(out int count);
-            if (ping != null)
-            {
-                Trace("Marking PING as failed (queue length: " + count + ")");
-                ping.Fail(failureType, null);
-                CompleteSyncOrAsync(ping);
-            }
             oldState = default(State); // only defined when isCurrent = true
             if (isCurrent = (physical == connection))
             {
@@ -339,6 +310,25 @@ internal void OnDisconnected(ConnectionFailureType failureType, PhysicalConnecti
             }
         }
 
+        private Message DequeueNextPendingBacklog()
+        {
+            lock(_preconnectBacklog)
+            {
+                return _preconnectBacklog.Count == 0 ? null : _preconnectBacklog.Dequeue();
+            }
+        }
+        void WritePendingBacklog(PhysicalConnection connection)
+        {
+            if(connection != null)
+            {
+                Message next;
+                do
+                {
+                    next = DequeueNextPendingBacklog();
+                    WriteMessageDirect(connection, next);
+                } while (next != null);
+            }
+        }
         internal void OnFullyEstablished(PhysicalConnection connection)
         {
             Trace("OnFullyEstablished");
@@ -348,8 +338,9 @@ internal void OnFullyEstablished(PhysicalConnection connection)
                 LastException = null;
                 Interlocked.Exchange(ref failConnectCount, 0);
                 ServerEndPoint.OnFullyEstablished(connection);
-                Multiplexer.RequestWrite(this, true);
-                if(ConnectionType == ConnectionType.Interactive) ServerEndPoint.CheckInfoReplication();
+                WritePendingBacklog(connection);
+
+                if (ConnectionType == ConnectionType.Interactive) ServerEndPoint.CheckInfoReplication();
             }
             else
             {
@@ -389,10 +380,6 @@ internal void OnHeartbeat(bool ifConnectedOnly)
                             using (snapshot) { } // dispose etc
                             TryConnect(null);
                         }
-                        if (!ifConnectedOnly)
-                        {
-                            AbortUnsent();
-                        }
                         break;
                     case (int)State.ConnectedEstablishing:
                     case (int)State.ConnectedEstablished:
@@ -426,7 +413,7 @@ internal void OnHeartbeat(bool ifConnectedOnly)
                                     OnDisconnected(ConnectionFailureType.SocketFailure, tmp, out bool ignore, out State oldState);
                                 }
                             }
-                            else if (!queue.Any() && tmp.GetSentAwaitingResponseCount() != 0)
+                            else if (tmp.GetSentAwaitingResponseCount() != 0)
                             {
                                 // there's a chance this is a dead socket; sending data will shake that
                                 // up a bit, so if we have an empty unsent queue and a non-empty sent
@@ -439,17 +426,12 @@ internal void OnHeartbeat(bool ifConnectedOnly)
                         Interlocked.Exchange(ref connectTimeoutRetryCount, 0);
                         if (!ifConnectedOnly)
                         {
-                            AbortUnsent();
                             Multiplexer.Trace("Resurrecting " + ToString());
                             GetConnection(null);
                         }
                         break;
                     default:
                         Interlocked.Exchange(ref connectTimeoutRetryCount, 0);
-                        if (!ifConnectedOnly)
-                        {
-                            AbortUnsent();
-                        }
                         break;
                 }
             }
@@ -493,159 +475,65 @@ internal bool TryEnqueue(List<Message> messages, bool isSlave)
             {
                 return false;
             }
-            bool reqWrite = false;
+
+            var physical = this.physical;
+            if (physical == null) return false;
             foreach (var message in messages)
             {   // deliberately not taking a single lock here; we don't care if
                 // other threads manage to interleave - in fact, it would be desirable
                 // (to avoid a batch monopolising the connection)
-                if (queue.Push(message)) reqWrite = true;
+                WriteMessageDirect(physical, message);
                 LogNonPreferred(message.Flags, isSlave);
             }
-            Trace("Now pending: " + GetPendingCount());
-            if (reqWrite) // was empty before
-            {
-                Multiplexer.RequestWrite(this, false);
-            }
             return true;
         }
 
+        private readonly object WriteLock = new object();
+
         /// <summary>
-        /// This writes a message **directly** to the output stream; note
-        /// that this ignores the queue, so should only be used *either*
-        /// from the regular dequeue loop, *or* from the "I've just
-        /// connected" handshake (when there is no dequeue loop) - otherwise,
-        /// you can pretty much assume you're going to destroy the stream
+        /// This writes a message to the output stream
         /// </summary>
-        internal bool WriteMessageDirect(PhysicalConnection tmp, Message next)
+        internal bool WriteMessageDirect(PhysicalConnection physical, Message next)
         {
             Trace("Writing: " + next);
-            var messageIsSent = false;
-            if (next is IMultiMessage)
-            {
-                SelectDatabase(tmp, next); // need to switch database *before* the transaction
-                foreach (var subCommand in ((IMultiMessage)next).GetMessages(tmp))
-                {
-                    if (!WriteMessageToServer(tmp, subCommand))
-                    {
-                        // we screwed up; abort; note that WriteMessageToServer already
-                        // killed the underlying connection
-                        Trace("Unable to write to server");
-                        next.Fail(ConnectionFailureType.ProtocolFailure, null);
-                        CompleteSyncOrAsync(next);
-                        return false;
-                    }
-                    //The parent message (next) may be returned from GetMessages
-                    //and should not be marked as sent again below
-                    messageIsSent = messageIsSent || subCommand == next;
-                }
-                if (!messageIsSent)
-                {
-                    next.SetRequestSent();
-                }
 
-                return true;
-            }
-            else
+            bool result;
+            lock (WriteLock)
             {
-                return WriteMessageToServer(tmp, next);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static ValueTask<T> AsResult<T>(T value) => new ValueTask<T>(value);
-
-        internal async ValueTask<WriteResult> WriteQueueAsync(int maxWork)
-        {
-            bool weAreWriter = false;
-            PhysicalConnection conn = null;
-            try
-            {
-                Trace("Writing queue from bridge");
-
-                weAreWriter = Interlocked.CompareExchange(ref activeWriters, 1, 0) == 0;
-                if (!weAreWriter)
-                {
-                    Trace("(aborting: existing writer)");
-                    return WriteResult.CompetingWriter;
-                }
-
-                conn = GetConnection(null);
-                if (conn == null)
+                var messageIsSent = false;
+                if (next is IMultiMessage)
                 {
-                    AbortUnsent();
-                    Trace("Connection not available; exiting");
-                    return WriteResult.NoConnection;
-                }
-
-                Message last;
-                int count = 0;
-                while (true)
-                {
-                    var next = queue.Dequeue();
-                    if (next == null)
+                    SelectDatabase(physical, next); // need to switch database *before* the transaction
+                    foreach (var subCommand in ((IMultiMessage)next).GetMessages(physical))
                     {
-                        Trace("Nothing to write; exiting");
-                        if(count == 0)
+                        if (!WriteMessageToServer(physical, subCommand))
                         {
-                            await conn.FlushAsync(); // only flush on an empty run
-                            return WriteResult.NothingToDo;
+                            // we screwed up; abort; note that WriteMessageToServer already
+                            // killed the underlying connection
+                            Trace("Unable to write to server");
+                            next.Fail(ConnectionFailureType.ProtocolFailure, null);
+                            CompleteSyncOrAsync(next);
+                            return false;
                         }
-                        return WriteResult.QueueEmptyAfterWrite;
+                        //The parent message (next) may be returned from GetMessages
+                        //and should not be marked as sent again below
+                        messageIsSent = messageIsSent || subCommand == next;
                     }
-                    last = next;
-
-                    Trace("Now pending: " + GetPendingCount());
-                    if (!WriteMessageDirect(conn, next))
+                    if (!messageIsSent)
                     {
-                        AbortUnsent();
-                        Trace("write failed; connection is toast; exiting");
-                        return WriteResult.NoConnection;
+                        next.SetRequestSent(); // well, it was attempted, at least...
                     }
-                    count++;
-                    if (maxWork > 0 && count >= maxWork)
-                    {
-                        Trace("Work limit; exiting");
-                        Trace(last != null, "Flushed up to: " + last);
-                        await conn.FlushAsync();
-                        break;
-                    }
-                }
-            }
-            catch (IOException ex)
-            {
-                if (conn != null)
-                {
-                    conn.RecordConnectionFailed(ConnectionFailureType.SocketFailure, ex);
-                    conn = null;
+
+                    result = true;
                 }
-                AbortUnsent();
-            }
-            catch (Exception ex)
-            {
-                AbortUnsent();
-                OnInternalError(ex);
-            }
-            finally
-            {
-                if (weAreWriter)
+                else
                 {
-                    Interlocked.Exchange(ref activeWriters, 0);
-                    Trace("Exiting writer");
+                    result = WriteMessageToServer(physical, next);
                 }
+                physical.WakeWriterAndCheckForThrottle();
             }
-            return queue.Any() ? WriteResult.MoreWork : WriteResult.QueueEmptyAfterWrite;
-        }
 
-        private void AbortUnsent()
-        {
-            var dead = queue.DequeueAll();
-            Trace(dead.Length != 0, "Aborting " + dead.Length + " messages");
-            for (int i = 0; i < dead.Length; i++)
-            {
-                var msg = dead[i];
-                msg.Fail(ConnectionFailureType.UnableToResolvePhysicalConnection, null);
-                CompleteSyncOrAsync(msg);
-            }
+            return result;
         }
 
         private State ChangeState(State newState)
@@ -656,11 +544,6 @@ private State ChangeState(State newState)
             if (oldState != newState)
             {
                 Multiplexer.Trace(ConnectionType + " state changed from " + oldState + " to " + newState);
-
-                if (newState == State.Disconnected)
-                {
-                    AbortUnsent();
-                }
             }
             return oldState;
         }

StackExchange.Redis/StackExchange/Redis/PhysicalConnection.cs

@@ -169,14 +169,14 @@ public void RecordConnectionFailed(ConnectionFailureType failureType, ref Socket
 
             // stop anything new coming in...
             Bridge.Trace("Failed: " + failureType);
-            int @in = -1, ar = -1;
+            int @in = -1;
             managerState = SocketManager.ManagerState.RecordConnectionFailed_OnDisconnected;
             Bridge.OnDisconnected(failureType, this, out bool isCurrent, out PhysicalBridge.State oldState);
             if (oldState == PhysicalBridge.State.ConnectedEstablished)
             {
                 try
                 {
-                    @in = GetAvailableInboundBytes(out ar);
+                    @in = GetAvailableInboundBytes();
                 }
                 catch { /* best effort only */ }
             }
@@ -211,23 +211,16 @@ void add(string lk, string sk, string v)
                     add("Last-Write", "last-write", (unchecked(now - lastWrite) / 1000) + "s ago");
                     add("Unanswered-Write", "unanswered-write", (unchecked(now - unansweredRead) / 1000) + "s ago");
                     add("Keep-Alive", "keep-alive", Bridge.ServerEndPoint.WriteEverySeconds + "s");
-                    add("Pending", "pending", Bridge.GetPendingCount().ToString());
                     add("Previous-Physical-State", "state", oldState.ToString());
 
                     if (@in >= 0)
                     {
                         add("Inbound-Bytes", "in", @in.ToString());
-                        add("Active-Readers", "ar", ar.ToString());
                     }
 
                     add("Last-Heartbeat", "last-heartbeat", (lastBeat == 0 ? "never" : ((unchecked(now - lastBeat) / 1000) + "s ago")) + (Bridge.IsBeating ? " (mid-beat)" : ""));
                     add("Last-Multiplexer-Heartbeat", "last-mbeat", Multiplexer.LastHeartbeatSecondsAgo + "s ago");
                     add("Last-Global-Heartbeat", "global", ConnectionMultiplexer.LastGlobalHeartbeatSecondsAgo + "s ago");
-#if FEATURE_SOCKET_MODE_POLL
-                    var mgr = Bridge.Multiplexer.SocketManager;
-                    add("SocketManager-State", "mgr", mgr.State.ToString());
-                    add("Last-Error", "err", mgr.LastErrorTimeRelative());
-#endif
                 }
 
                 var ex = innerException == null
@@ -592,6 +585,12 @@ private static int WriteRaw(Span<byte> span, long value, bool withLengthPrefix =
             return WriteCrlf(span, offset);
         }
 
+        internal void WakeWriterAndCheckForThrottle()
+        {
+            var flush = _ioPipe.Output.FlushAsync();
+            if (!flush.IsCompletedSuccessfully) flush.AsTask().Wait();
+        }
+
         static readonly byte[] NullBulkString = Encoding.ASCII.GetBytes("$-1\r\n"), EmptyBulkString = Encoding.ASCII.GetBytes("$0\r\n\r\n");
         private static void WriteUnified(PipeWriter writer, byte[] value)
         {
@@ -801,15 +800,8 @@ private static void WriteUnified(PipeWriter writer, long value)
             var bytes = WriteRaw(span, value, withLengthPrefix: true, offset: 1);
             writer.Advance(bytes);
         }
-        
 
-        private int haveReader;
-
-        internal int GetAvailableInboundBytes(out int activeReaders)
-        {
-            activeReaders = Interlocked.CompareExchange(ref haveReader, 0, 0);
-            return socketToken.Available;
-        }
+        internal int GetAvailableInboundBytes() => socketToken.Available;
 
         private static LocalCertificateSelectionCallback GetAmbientCertificateCallback()
         {

StackExchange.Redis/StackExchange/Redis/ServerEndPoint.cs

@@ -367,15 +367,15 @@ internal ServerCounters GetCounters()
             return counters;
         }
 
-        internal int GetOutstandingCount(RedisCommand command, out int inst, out int qu, out int qs, out int qc, out int wr, out int wq, out int @in, out int ar)
+        internal int GetOutstandingCount(RedisCommand command, out int inst, out int qs, out int qc, out int @in)
         {
             var bridge = GetBridge(command, false);
             if (bridge == null)
             {
-                return inst = qu = qs = qc = wr = wq = @in = ar = 0;
+                return inst = qs = qc = @in = 0;
             }
 
-            return bridge.GetOutstandingCount(out inst, out qu, out qs, out qc, out wr, out wq, out @in, out ar);
+            return bridge.GetOutstandingCount(out inst, out qs, out qc, out @in);
         }
 
         internal string GetProfile()

StackExchange.Redis/StackExchange/Redis/SocketManager.cs

 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.IO.Pipelines;
 using System.Net;
@@ -13,9 +12,7 @@ namespace StackExchange.Redis
     internal enum SocketMode
     {
         Abort,
-        [Obsolete("just don't", error: true)]
-        Poll,
-        Async
+        Async,
     }
 
     /// <summary>
@@ -108,11 +105,7 @@ internal enum ManagerState
             ProcessReadQueue,
             ProcessErrorQueue,
         }
-
-        private readonly Queue<PhysicalBridge> writeQueue = new Queue<PhysicalBridge>();
-        private bool isDisposed;
-        private readonly bool useHighPrioritySocketThreads = true;
-
+        
         /// <summary>
         /// Gets the name of this SocketManager instance
         /// </summary>
@@ -133,12 +126,7 @@ public SocketManager(string name, bool useHighPrioritySocketThreads)
         {
             if (string.IsNullOrWhiteSpace(name)) name = GetType().Name;
             Name = name;
-            this.useHighPrioritySocketThreads = useHighPrioritySocketThreads;
-
-            _writeOneQueueAsync = () => WriteOneQueueAsync();
-
-            Task.Run(() => WriteAllQueuesAsync());
-
+            
             const int Receive_PauseWriterThreshold = 1024 * 1024 * 1024; // let's give it up to 1GiB of buffer for now
 
             var defaultPipeOptions = PipeOptions.Default;
@@ -159,9 +147,6 @@ public SocketManager(string name, bool useHighPrioritySocketThreads)
         readonly DedicatedThreadPoolPipeScheduler _scheduler;
         internal readonly PipeOptions SendPipeOptions, ReceivePipeOptions;
 
-        private readonly Func<Task> _writeOneQueueAsync;
-
-
         private enum CallbackOperation
         {
             Read,
@@ -174,12 +159,6 @@ private enum CallbackOperation
         public void Dispose()
         {
             _scheduler?.Dispose();
-            lock (writeQueue)
-            {
-                // make sure writer threads know to exit
-                isDisposed = true;
-                Monitor.PulseAll(writeQueue);
-            }
             OnDispose();
         }
         internal SocketToken BeginConnect(EndPoint endpoint, ISocketCallback callback, ConnectionMultiplexer multiplexer, TextWriter log)
@@ -247,27 +226,6 @@ void proxyCallback(IAsyncResult ar)
             return token;
         }
 
-
-
-        internal void RequestWrite(PhysicalBridge bridge, bool forced)
-        {
-            if (Interlocked.CompareExchange(ref bridge.inWriteQueue, 1, 0) == 0 || forced)
-            {
-                lock (writeQueue)
-                {
-                    writeQueue.Enqueue(bridge);
-                    if (writeQueue.Count == 1)
-                    {
-                        Monitor.PulseAll(writeQueue);
-                    }
-                    else if (writeQueue.Count >= 2)
-                    { // struggling are we? let's have some help dealing with the backlog
-                        Task.Run(_writeOneQueueAsync);
-                    }
-                }
-            }
-        }
-        
         internal void Shutdown(SocketToken token)
         {
             Shutdown(token.Socket);
@@ -345,88 +303,5 @@ private void Shutdown(Socket socket)
                 try { socket.Dispose(); } catch { }
             }
         }
-
-        private async Task WriteAllQueuesAsync()
-        {
-            while (true)
-            {
-                PhysicalBridge bridge;
-                lock (writeQueue)
-                {
-                    if (writeQueue.Count == 0)
-                    {
-                        if (isDisposed) break; // <========= exit point
-                        Monitor.Wait(writeQueue);
-                        if (isDisposed) break; // (woken by Dispose)
-                        if (writeQueue.Count == 0) continue; // still nothing...
-                    }
-                    bridge = writeQueue.Dequeue();
-                }
-
-                switch (await bridge.WriteQueueAsync(200))
-                {
-                    case WriteResult.MoreWork:
-                    case WriteResult.QueueEmptyAfterWrite:
-                        // back of the line!
-                        lock (writeQueue)
-                        {
-                            writeQueue.Enqueue(bridge);
-                        }
-                        break;
-                    case WriteResult.CompetingWriter:
-                        break;
-                    case WriteResult.NoConnection:
-                        Interlocked.Exchange(ref bridge.inWriteQueue, 0);
-                        break;
-                    case WriteResult.NothingToDo:
-                        if (!bridge.ConfirmRemoveFromWriteQueue())
-                        { // more snuck in; back of the line!
-                            lock (writeQueue)
-                            {
-                                writeQueue.Enqueue(bridge);
-                            }
-                        }
-                        break;
-                }
-            }
-        }
-
-        private Task WriteOneQueueAsync()
-        {
-            PhysicalBridge bridge;
-            lock (writeQueue)
-            {
-                bridge = writeQueue.Count == 0 ? null : writeQueue.Dequeue();
-            }
-            if (bridge == null) return Task.CompletedTask;
-            return WriteOneQueueAsyncImpl(bridge);
-        }
-        private async Task WriteOneQueueAsyncImpl(PhysicalBridge bridge)
-        {
-            bool keepGoing;
-            do
-            {
-                switch (await bridge.WriteQueueAsync(-1))
-                {
-                    case WriteResult.MoreWork:
-                    case WriteResult.QueueEmptyAfterWrite:
-                        keepGoing = true;
-                        break;
-                    case WriteResult.NothingToDo:
-                        keepGoing = !bridge.ConfirmRemoveFromWriteQueue();
-                        break;
-                    case WriteResult.CompetingWriter:
-                        keepGoing = false;
-                        break;
-                    case WriteResult.NoConnection:
-                        Interlocked.Exchange(ref bridge.inWriteQueue, 0);
-                        keepGoing = false;
-                        break;
-                    default:
-                        keepGoing = false;
-                        break;
-                }
-            } while (keepGoing);
-        }
     }
 }