STE: Provide indicators of progress (#517)

nayato · web-flow · commit a9d0723ba599 · 2019-10-16T22:27:45.000-07:00
extra: give access to executors within executor group
diff --git a/src/DotNetty.Common/Concurrency/AbstractEventExecutor.cs b/src/DotNetty.Common/Concurrency/AbstractEventExecutor.cs
@@ -4,6 +4,7 @@
 namespace DotNetty.Common.Concurrency
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading;
     using System.Threading.Tasks;
     using DotNetty.Common.Internal.Logging;
@@ -46,6 +47,11 @@ protected AbstractEventExecutor(IEventExecutorGroup parent)
         /// <inheritdoc cref="IEventExecutor"/>
         public bool InEventLoop => this.IsInEventLoop(Thread.CurrentThread);
 
+        /// <inheritdoc cref="IEventExecutor" />
+        public IEnumerable<IEventExecutor> Items => this.GetItems();
+
+        protected abstract IEnumerable<IEventExecutor> GetItems();
+
         /// <inheritdoc cref="IEventExecutor"/>
         public abstract bool IsInEventLoop(Thread thread);
 
diff --git a/src/DotNetty.Common/Concurrency/AbstractEventExecutorGroup.cs b/src/DotNetty.Common/Concurrency/AbstractEventExecutorGroup.cs
@@ -4,6 +4,7 @@
 namespace DotNetty.Common.Concurrency
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading;
     using System.Threading.Tasks;
 
@@ -20,6 +21,8 @@ public abstract class AbstractEventExecutorGroup : IEventExecutorGroup
 
         public abstract Task TerminationCompletion { get; }
 
+        public IEnumerable<IEventExecutor> Items => this.GetItems();
+
         public abstract IEventExecutor GetNext();
 
         public void Execute(IRunnable task) => this.GetNext().Execute(task);
@@ -65,5 +68,7 @@ public abstract class AbstractEventExecutorGroup : IEventExecutorGroup
         public Task ShutdownGracefullyAsync() => this.ShutdownGracefullyAsync(DefaultShutdownQuietPeriod, DefaultShutdownTimeout);
 
         public abstract Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout);
+
+        protected abstract IEnumerable<IEventExecutor> GetItems();
     }
 }
diff --git a/src/DotNetty.Common/Concurrency/IEventExecutorGroup.cs b/src/DotNetty.Common/Concurrency/IEventExecutorGroup.cs
@@ -4,13 +4,19 @@
 namespace DotNetty.Common.Concurrency
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading.Tasks;
 
     /// <summary>
     /// Provides an access to a set of <see cref="IEventExecutor"/>s it manages.
     /// </summary>
     public interface IEventExecutorGroup : IScheduledExecutorService
     {
+        /// <summary>
+        /// Returns list of owned event executors.
+        /// </summary>
+        IEnumerable<IEventExecutor> Items { get; }
+
         /// <summary>
         ///     Returns <c>true</c> if and only if this executor is being shut down via <see cref="ShutdownGracefullyAsync()" />.
         /// </summary>
diff --git a/src/DotNetty.Common/Concurrency/SingleThreadEventExecutor.cs b/src/DotNetty.Common/Concurrency/SingleThreadEventExecutor.cs
@@ -45,6 +45,7 @@ public class SingleThreadEventExecutor : AbstractScheduledEventExecutor
         PreciseTimeSpan gracefulShutdownQuietPeriod;
         PreciseTimeSpan gracefulShutdownTimeout;
         readonly ISet<Action> shutdownHooks = new HashSet<Action>();
+        long progress;
 
         /// <summary>Creates a new instance of <see cref="SingleThreadEventExecutor"/>.</summary>
         public SingleThreadEventExecutor(string threadName, TimeSpan breakoutInterval)
@@ -86,6 +87,21 @@ protected SingleThreadEventExecutor(IEventExecutorGroup parent, string threadNam
         /// </summary>
         public TaskScheduler Scheduler => this.scheduler;
 
+        /// <summary>
+        ///     Allows to track whether executor is progressing through its backlog. Useful for diagnosing / mitigating stalls due to blocking calls in conjunction with IsBacklogEmpty property.
+        /// </summary>
+        public long Progress => Volatile.Read(ref this.progress);
+
+        /// <summary>
+        ///     Indicates whether executor's backlog is empty. Useful for diagnosing / mitigating stalls due to blocking calls in conjunction with Progress property.
+        /// </summary>
+        public bool IsBacklogEmpty => this.taskQueue.IsEmpty;
+
+        /// <summary>
+        ///     Gets length of backlog of tasks queued for immediate execution.
+        /// </summary>
+        public int BacklogLength => this.taskQueue.Count;
+
         void Loop()
         {
             this.SetCurrentExecutor(this);
@@ -140,6 +156,8 @@ public override void Execute(IRunnable task)
             }
         }
 
+        protected override IEnumerable<IEventExecutor> GetItems() => new[] { this };
+
         protected void WakeUp(bool inEventLoop)
         {
             if (!inEventLoop || (this.executionState == ST_SHUTTING_DOWN))
@@ -152,12 +170,12 @@ protected void WakeUp(bool inEventLoop)
         /// Adds an <see cref="Action"/> which will be executed on shutdown of this instance.
         /// </summary>
         /// <param name="action">The <see cref="Action"/> to run on shutdown.</param>
-        public void AddShutdownHook(Action action) 
+        public void AddShutdownHook(Action action)
         {
-            if (this.InEventLoop) 
+            if (this.InEventLoop)
             {
                 this.shutdownHooks.Add(action);
-            } 
+            }
             else
             {
                 this.Execute(() => this.shutdownHooks.Add(action));
@@ -169,53 +187,53 @@ public void AddShutdownHook(Action action)
         /// executed on shutdown of this instance.
         /// </summary>
         /// <param name="action">The <see cref="Action"/> to remove.</param>
-        public void RemoveShutdownHook(Action action) 
+        public void RemoveShutdownHook(Action action)
         {
-            if (this.InEventLoop) 
+            if (this.InEventLoop)
             {
                 this.shutdownHooks.Remove(action);
-            } 
+            }
             else
             {
                 this.Execute(() => this.shutdownHooks.Remove(action));
             }
         }
 
-        bool RunShutdownHooks() 
+        bool RunShutdownHooks()
         {
             bool ran = false;
-            
+
             // Note shutdown hooks can add / remove shutdown hooks.
-            while (this.shutdownHooks.Count > 0) 
+            while (this.shutdownHooks.Count > 0)
             {
                 var copy = this.shutdownHooks.ToArray();
                 this.shutdownHooks.Clear();
 
                 for (var i = 0; i < copy.Length; i++)
                 {
-                    try 
+                    try
                     {
                         copy[i]();
-                    } 
-                    catch (Exception ex) 
+                    }
+                    catch (Exception ex)
                     {
                         Logger.Warn("Shutdown hook raised an exception.", ex);
-                    } 
-                    finally 
+                    }
+                    finally
                     {
                         ran = true;
                     }
                 }
             }
 
-            if (ran) 
+            if (ran)
             {
                 this.lastExecutionTime = PreciseTimeSpan.FromStart;
             }
 
             return ran;
         }
-        
+
 
         /// <inheritdoc cref="IEventExecutor"/>
         public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout)
@@ -398,6 +416,7 @@ protected bool RunAllTasks()
 
             while (true)
             {
+                Volatile.Write(ref this.progress, this.progress + 1); // volatile write is enough as this is the only thread ever writing
                 SafeExecute(task);
                 task = this.PollTask();
                 if (task == null)
diff --git a/src/DotNetty.Transport.Libuv/DispatcherEventLoop.cs b/src/DotNetty.Transport.Libuv/DispatcherEventLoop.cs
@@ -4,6 +4,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Runtime.InteropServices;
@@ -69,5 +70,7 @@ internal void Dispatch(NativeHandle handle)
         public Task RegisterAsync(IChannel channel) => channel.Unsafe.RegisterAsync(this);
 
         public new IEventLoopGroup Parent => (IEventLoopGroup)base.Parent;
+
+        public new IEnumerable<IEventLoop> Items => new[] { this };
     }
 }
diff --git a/src/DotNetty.Transport.Libuv/DispatcherEventLoopGroup.cs b/src/DotNetty.Transport.Libuv/DispatcherEventLoopGroup.cs
@@ -6,6 +6,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading.Tasks;
     using DotNetty.Common.Concurrency;
     using DotNetty.Transport.Channels;
@@ -29,6 +30,10 @@ public DispatcherEventLoopGroup()
 
         internal DispatcherEventLoop Dispatcher => this.dispatcherEventLoop;
 
+        protected override IEnumerable<IEventExecutor> GetItems() => new[] { this.dispatcherEventLoop };
+
+        public new IEnumerable<IEventLoop> Items => new[] { this.dispatcherEventLoop };
+
         IEventLoop IEventLoopGroup.GetNext() => (IEventLoop)this.GetNext();
 
         public override IEventExecutor GetNext() => this.dispatcherEventLoop;
diff --git a/src/DotNetty.Transport.Libuv/EventLoop.cs b/src/DotNetty.Transport.Libuv/EventLoop.cs
@@ -3,6 +3,7 @@
 
 namespace DotNetty.Transport.Libuv
 {
+    using System.Collections.Generic;
     using System.Threading.Tasks;
     using DotNetty.Transport.Channels;
 
@@ -19,5 +20,7 @@ public EventLoop(IEventLoopGroup parent, string threadName)
         public Task RegisterAsync(IChannel channel) => channel.Unsafe.RegisterAsync(this);
 
         public new IEventLoopGroup Parent => (IEventLoopGroup)base.Parent;
+
+        public new IEnumerable<IEventLoop> Items => new[] { this };
     }
 }
diff --git a/src/DotNetty.Transport.Libuv/EventLoopGroup.cs b/src/DotNetty.Transport.Libuv/EventLoopGroup.cs
@@ -6,6 +6,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Linq;
     using System.Threading;
     using System.Threading.Tasks;
@@ -27,6 +28,8 @@ public sealed class EventLoopGroup : AbstractEventExecutorGroup, IEventLoopGroup
 
         public override Task TerminationCompletion { get; }
 
+        public new IEnumerable<IEventLoop> Items => this.eventLoops;
+
         public EventLoopGroup()
             : this(DefaultEventLoopCount)
         {
@@ -119,5 +122,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time
             }
             return this.TerminationCompletion;
         }
+
+        protected override IEnumerable<IEventExecutor> GetItems() => this.eventLoops;
     }
 }
diff --git a/src/DotNetty.Transport.Libuv/LoopExecutor.cs b/src/DotNetty.Transport.Libuv/LoopExecutor.cs
@@ -7,6 +7,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Threading.Tasks;
@@ -17,7 +18,6 @@ namespace DotNetty.Transport.Libuv
     using System.Threading;
     using DotNetty.Common;
     using DotNetty.Transport.Libuv.Native;
-
     using Timer = Native.Timer;
 
     class LoopExecutor : AbstractScheduledEventExecutor
@@ -297,7 +297,7 @@ void RunAllTasks(long timeout)
             long runTasks = 0;
             long executionTime;
             this.wakeUp = false;
-            for (;;)
+            for (; ; )
             {
                 SafeExecute(task);
 
@@ -402,7 +402,7 @@ static bool RunAllTasksFrom(IQueue<IRunnable> taskQueue)
             {
                 return false;
             }
-            for (;;)
+            for (; ; )
             {
                 SafeExecute(task);
                 task = PollTaskFrom(taskQueue);
@@ -488,7 +488,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time
             bool inEventLoop = this.InEventLoop;
             bool wakeUpLoop;
             int oldState;
-            for (;;)
+            for (; ; )
             {
                 if (this.IsShuttingDown)
                 {
@@ -540,5 +540,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time
 
             return this.TerminationCompletion;
         }
+
+        protected override IEnumerable<IEventExecutor> GetItems() => new[] { this };
     }
 }
diff --git a/src/DotNetty.Transport.Libuv/WorkerEventLoop.cs b/src/DotNetty.Transport.Libuv/WorkerEventLoop.cs
@@ -7,6 +7,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Threading.Tasks;
@@ -112,6 +113,8 @@ void OnRead(Pipe handle, int status)
 
         public new IEventLoopGroup Parent => (IEventLoopGroup)base.Parent;
 
+        IEnumerable<IEventLoop> IEventLoopGroup.Items => new[] { this };
+
         sealed class PipeConnect : ConnectRequest
         {
             const int MaximumRetryCount = 10;
diff --git a/src/DotNetty.Transport.Libuv/WorkerEventLoopGroup.cs b/src/DotNetty.Transport.Libuv/WorkerEventLoopGroup.cs
@@ -6,6 +6,7 @@
 namespace DotNetty.Transport.Libuv
 {
     using System;
+    using System.Collections.Generic;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
     using System.Linq;
@@ -84,6 +85,8 @@ public WorkerEventLoopGroup(DispatcherEventLoopGroup eventLoopGroup, int eventLo
 
         internal string PipeName { get; }
 
+        IEnumerable<IEventLoop> IEventLoopGroup.Items => this.eventLoops;
+
         internal void Accept(NativeHandle handle)
         {
             Debug.Assert(this.dispatcherLoop != null);
@@ -126,5 +129,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time
             }
             return this.TerminationCompletion;
         }
+
+        protected override IEnumerable<IEventExecutor> GetItems() => this.eventLoops;
     }
 }
diff --git a/src/DotNetty.Transport/Channels/AffinitizedEventLoopGroup.cs b/src/DotNetty.Transport/Channels/AffinitizedEventLoopGroup.cs
@@ -4,6 +4,7 @@
 namespace DotNetty.Transport.Channels
 {
     using System;
+    using System.Collections.Generic;
     using System.Threading.Tasks;
     using DotNetty.Common.Concurrency;
 
@@ -23,6 +24,10 @@ public class AffinitizedEventLoopGroup : AbstractEventExecutorGroup, IEventLoopG
         /// <inheritdoc cref="IEventExecutorGroup"/>
         public override Task TerminationCompletion => this.innerGroup.TerminationCompletion;
 
+        protected override IEnumerable<IEventExecutor> GetItems() => this.innerGroup.Items;
+
+        public new IEnumerable<IEventLoop> Items => ((IEventLoopGroup)this.innerGroup).Items;
+
         /// <summary>
         /// Creates a new instance of <see cref="AffinitizedEventLoopGroup"/>.
         /// </summary>
diff --git a/src/DotNetty.Transport/Channels/Embedded/EmbeddedEventLoop.cs b/src/DotNetty.Transport/Channels/Embedded/EmbeddedEventLoop.cs
diff --git a/src/DotNetty.Transport/Channels/IEventLoopGroup.cs b/src/DotNetty.Transport/Channels/IEventLoopGroup.cs
diff --git a/src/DotNetty.Transport/Channels/MultithreadEventLoopGroup.cs b/src/DotNetty.Transport/Channels/MultithreadEventLoopGroup.cs
diff --git a/src/DotNetty.Transport/Channels/SingleThreadEventLoop.cs b/src/DotNetty.Transport/Channels/SingleThreadEventLoop.cs

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`namespace DotNetty.Common.Concurrency`
`5`	`5`	`{`
`6`	`6`	`using System;`
	`7`	`+ using System.Collections.Generic;`
`7`	`8`	`using System.Threading;`
`8`	`9`	`using System.Threading.Tasks;`
`9`	`10`
`@@ -20,6 +21,8 @@ public abstract class AbstractEventExecutorGroup : IEventExecutorGroup`
`20`	`21`
`21`	`22`	`public abstract Task TerminationCompletion { get; }`
`22`	`23`
	`24`	`+ public IEnumerable<IEventExecutor> Items => this.GetItems();`
	`25`	`+`
`23`	`26`	`public abstract IEventExecutor GetNext();`
`24`	`27`
`25`	`28`	`public void Execute(IRunnable task) => this.GetNext().Execute(task);`
`@@ -65,5 +68,7 @@ public abstract class AbstractEventExecutorGroup : IEventExecutorGroup`
`65`	`68`	`public Task ShutdownGracefullyAsync() => this.ShutdownGracefullyAsync(DefaultShutdownQuietPeriod, DefaultShutdownTimeout);`
`66`	`69`
`67`	`70`	`public abstract Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout);`
	`71`	`+`
	`72`	`+ protected abstract IEnumerable<IEventExecutor> GetItems();`
`68`	`73`	`}`
`69`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ public class SingleThreadEventExecutor : AbstractScheduledEventExecutor`
`45`	`45`	`PreciseTimeSpan gracefulShutdownQuietPeriod;`
`46`	`46`	`PreciseTimeSpan gracefulShutdownTimeout;`
`47`	`47`	`readonly ISet<Action> shutdownHooks = new HashSet<Action>();`
	`48`	`+ long progress;`
`48`	`49`
`49`	`50`	`/// <summary>Creates a new instance of <see cref="SingleThreadEventExecutor"/>.</summary>`
`50`	`51`	`public SingleThreadEventExecutor(string threadName, TimeSpan breakoutInterval)`
`@@ -86,6 +87,21 @@ protected SingleThreadEventExecutor(IEventExecutorGroup parent, string threadNam`
`86`	`87`	`/// </summary>`
`87`	`88`	`public TaskScheduler Scheduler => this.scheduler;`
`88`	`89`
	`90`	`+ /// <summary>`
	`91`	`+ /// Allows to track whether executor is progressing through its backlog. Useful for diagnosing / mitigating stalls due to blocking calls in conjunction with IsBacklogEmpty property.`
	`92`	`+ /// </summary>`
	`93`	`+ public long Progress => Volatile.Read(ref this.progress);`
	`94`	`+`
	`95`	`+ /// <summary>`
	`96`	`+ /// Indicates whether executor's backlog is empty. Useful for diagnosing / mitigating stalls due to blocking calls in conjunction with Progress property.`
	`97`	`+ /// </summary>`
	`98`	`+ public bool IsBacklogEmpty => this.taskQueue.IsEmpty;`
	`99`	`+`
	`100`	`+ /// <summary>`
	`101`	`+ /// Gets length of backlog of tasks queued for immediate execution.`
	`102`	`+ /// </summary>`
	`103`	`+ public int BacklogLength => this.taskQueue.Count;`
	`104`	`+`
`89`	`105`	`void Loop()`
`90`	`106`	`{`
`91`	`107`	`this.SetCurrentExecutor(this);`
`@@ -140,6 +156,8 @@ public override void Execute(IRunnable task)`
`140`	`156`	`}`
`141`	`157`	`}`
`142`	`158`
	`159`	`+ protected override IEnumerable<IEventExecutor> GetItems() => new[] { this };`
	`160`	`+`
`143`	`161`	`protected void WakeUp(bool inEventLoop)`
`144`	`162`	`{`
`145`	`163`	`if (!inEventLoop \|\| (this.executionState == ST_SHUTTING_DOWN))`
`@@ -152,12 +170,12 @@ protected void WakeUp(bool inEventLoop)`
`152`	`170`	`/// Adds an <see cref="Action"/> which will be executed on shutdown of this instance.`
`153`	`171`	`/// </summary>`
`154`	`172`	`/// <param name="action">The <see cref="Action"/> to run on shutdown.</param>`
`155`		`- public void AddShutdownHook(Action action)`
	`173`	`+ public void AddShutdownHook(Action action)`
`156`	`174`	`{`
`157`		`- if (this.InEventLoop)`
	`175`	`+ if (this.InEventLoop)`
`158`	`176`	`{`
`159`	`177`	`this.shutdownHooks.Add(action);`
`160`		`- }`
	`178`	`+ }`
`161`	`179`	`else`
`162`	`180`	`{`
`163`	`181`	`this.Execute(() => this.shutdownHooks.Add(action));`
`@@ -169,53 +187,53 @@ public void AddShutdownHook(Action action)`
`169`	`187`	`/// executed on shutdown of this instance.`
`170`	`188`	`/// </summary>`
`171`	`189`	`/// <param name="action">The <see cref="Action"/> to remove.</param>`
`172`		`- public void RemoveShutdownHook(Action action)`
	`190`	`+ public void RemoveShutdownHook(Action action)`
`173`	`191`	`{`
`174`		`- if (this.InEventLoop)`
	`192`	`+ if (this.InEventLoop)`
`175`	`193`	`{`
`176`	`194`	`this.shutdownHooks.Remove(action);`
`177`		`- }`
	`195`	`+ }`
`178`	`196`	`else`
`179`	`197`	`{`
`180`	`198`	`this.Execute(() => this.shutdownHooks.Remove(action));`
`181`	`199`	`}`
`182`	`200`	`}`
`183`	`201`
`184`		`- bool RunShutdownHooks()`
	`202`	`+ bool RunShutdownHooks()`
`185`	`203`	`{`
`186`	`204`	`bool ran = false;`
`187`		`-`
	`205`	`+`
`188`	`206`	`// Note shutdown hooks can add / remove shutdown hooks.`
`189`		`- while (this.shutdownHooks.Count > 0)`
	`207`	`+ while (this.shutdownHooks.Count > 0)`
`190`	`208`	`{`
`191`	`209`	`var copy = this.shutdownHooks.ToArray();`
`192`	`210`	`this.shutdownHooks.Clear();`
`193`	`211`
`194`	`212`	`for (var i = 0; i < copy.Length; i++)`
`195`	`213`	`{`
`196`		`- try`
	`214`	`+ try`
`197`	`215`	`{`
`198`	`216`	`copy[i]();`
`199`		`- }`
`200`		`- catch (Exception ex)`
	`217`	`+ }`
	`218`	`+ catch (Exception ex)`
`201`	`219`	`{`
`202`	`220`	`Logger.Warn("Shutdown hook raised an exception.", ex);`
`203`		`- }`
`204`		`- finally`
	`221`	`+ }`
	`222`	`+ finally`
`205`	`223`	`{`
`206`	`224`	`ran = true;`
`207`	`225`	`}`
`208`	`226`	`}`
`209`	`227`	`}`
`210`	`228`
`211`		`- if (ran)`
	`229`	`+ if (ran)`
`212`	`230`	`{`
`213`	`231`	`this.lastExecutionTime = PreciseTimeSpan.FromStart;`
`214`	`232`	`}`
`215`	`233`
`216`	`234`	`return ran;`
`217`	`235`	`}`
`218`		`-`
	`236`	`+`
`219`	`237`
`220`	`238`	`/// <inheritdoc cref="IEventExecutor"/>`
`221`	`239`	`public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan timeout)`
`@@ -398,6 +416,7 @@ protected bool RunAllTasks()`
`398`	`416`
`399`	`417`	`while (true)`
`400`	`418`	`{`
	`419`	`+ Volatile.Write(ref this.progress, this.progress + 1); // volatile write is enough as this is the only thread ever writing`
`401`	`420`	`SafeExecute(task);`
`402`	`421`	`task = this.PollTask();`
`403`	`422`	`if (task == null)`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`namespace DotNetty.Transport.Libuv`
`5`	`5`	`{`
`6`	`6`	`using System;`
	`7`	`+ using System.Collections.Generic;`
`7`	`8`	`using System.Diagnostics;`
`8`	`9`	`using System.Diagnostics.Contracts;`
`9`	`10`	`using System.Runtime.InteropServices;`
`@@ -69,5 +70,7 @@ internal void Dispatch(NativeHandle handle)`
`69`	`70`	`public Task RegisterAsync(IChannel channel) => channel.Unsafe.RegisterAsync(this);`
`70`	`71`
`71`	`72`	`public new IEventLoopGroup Parent => (IEventLoopGroup)base.Parent;`
	`73`	`+`
	`74`	`+ public new IEnumerable<IEventLoop> Items => new[] { this };`
`72`	`75`	`}`
`73`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace DotNetty.Transport.Libuv`
`5`	`5`	`{`
	`6`	`+ using System.Collections.Generic;`
`6`	`7`	`using System.Threading.Tasks;`
`7`	`8`	`using DotNetty.Transport.Channels;`
`8`	`9`
`@@ -19,5 +20,7 @@ public EventLoop(IEventLoopGroup parent, string threadName)`
`19`	`20`	`public Task RegisterAsync(IChannel channel) => channel.Unsafe.RegisterAsync(this);`
`20`	`21`
`21`	`22`	`public new IEventLoopGroup Parent => (IEventLoopGroup)base.Parent;`
	`23`	`+`
	`24`	`+ public new IEnumerable<IEventLoop> Items => new[] { this };`
`22`	`25`	`}`
`23`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`namespace DotNetty.Transport.Libuv`
`7`	`7`	`{`
`8`	`8`	`using System;`
	`9`	`+ using System.Collections.Generic;`
`9`	`10`	`using System.Linq;`
`10`	`11`	`using System.Threading;`
`11`	`12`	`using System.Threading.Tasks;`
`@@ -27,6 +28,8 @@ public sealed class EventLoopGroup : AbstractEventExecutorGroup, IEventLoopGroup`
`27`	`28`
`28`	`29`	`public override Task TerminationCompletion { get; }`
`29`	`30`
	`31`	`+ public new IEnumerable<IEventLoop> Items => this.eventLoops;`
	`32`	`+`
`30`	`33`	`public EventLoopGroup()`
`31`	`34`	`: this(DefaultEventLoopCount)`
`32`	`35`	`{`
`@@ -119,5 +122,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time`
`119`	`122`	`}`
`120`	`123`	`return this.TerminationCompletion;`
`121`	`124`	`}`
	`125`	`+`
	`126`	`+ protected override IEnumerable<IEventExecutor> GetItems() => this.eventLoops;`
`122`	`127`	`}`
`123`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`namespace DotNetty.Transport.Libuv`
`8`	`8`	`{`
`9`	`9`	`using System;`
	`10`	`+ using System.Collections.Generic;`
`10`	`11`	`using System.Diagnostics;`
`11`	`12`	`using System.Diagnostics.Contracts;`
`12`	`13`	`using System.Threading.Tasks;`
`@@ -17,7 +18,6 @@ namespace DotNetty.Transport.Libuv`
`17`	`18`	`using System.Threading;`
`18`	`19`	`using DotNetty.Common;`
`19`	`20`	`using DotNetty.Transport.Libuv.Native;`
`20`		`-`
`21`	`21`	`using Timer = Native.Timer;`
`22`	`22`
`23`	`23`	`class LoopExecutor : AbstractScheduledEventExecutor`
`@@ -297,7 +297,7 @@ void RunAllTasks(long timeout)`
`297`	`297`	`long runTasks = 0;`
`298`	`298`	`long executionTime;`
`299`	`299`	`this.wakeUp = false;`
`300`		`- for (;;)`
	`300`	`+ for (; ; )`
`301`	`301`	`{`
`302`	`302`	`SafeExecute(task);`
`303`	`303`
`@@ -402,7 +402,7 @@ static bool RunAllTasksFrom(IQueue<IRunnable> taskQueue)`
`402`	`402`	`{`
`403`	`403`	`return false;`
`404`	`404`	`}`
`405`		`- for (;;)`
	`405`	`+ for (; ; )`
`406`	`406`	`{`
`407`	`407`	`SafeExecute(task);`
`408`	`408`	`task = PollTaskFrom(taskQueue);`
`@@ -488,7 +488,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time`
`488`	`488`	`bool inEventLoop = this.InEventLoop;`
`489`	`489`	`bool wakeUpLoop;`
`490`	`490`	`int oldState;`
`491`		`- for (;;)`
	`491`	`+ for (; ; )`
`492`	`492`	`{`
`493`	`493`	`if (this.IsShuttingDown)`
`494`	`494`	`{`
`@@ -540,5 +540,7 @@ public override Task ShutdownGracefullyAsync(TimeSpan quietPeriod, TimeSpan time`
`540`	`540`
`541`	`541`	`return this.TerminationCompletion;`
`542`	`542`	`}`
	`543`	`+`
	`544`	`+ protected override IEnumerable<IEventExecutor> GetItems() => new[] { this };`
`543`	`545`	`}`
`544`	`546`	`}`