[Core.MicroThreading] Modernize code

Author: Kryptos-FR

sources/assets/Stride.Core.Assets.CompilerApp/PackageBuilder.cs

@@ -347,7 +347,7 @@ private BuildResultCode BuildSlave()
                 }
 
                 // Create scheduler
-                var scheduler = new Scheduler();
+                using var scheduler = new Scheduler();
 
                 var status = ResultStatus.NotProcessed;
 

sources/buildengine/Stride.Core.BuildEngine/BuildEngineCommands.cs

@@ -172,7 +172,7 @@ public static BuildResultCode BuildSlave(BuilderOptions options)
                 RegisterRemoteLogger(processBuilderRemote);
 
                 // Create scheduler
-                var scheduler = new Scheduler();
+                using var scheduler = new Scheduler();
 
                 var status = ResultStatus.NotProcessed;
 

sources/core/Stride.Core.Design.Tests/TestMicroThreadLock.cs

@@ -18,7 +18,7 @@ public class TestMicroThreadLock
         [Fact]
         public void TestConcurrencyInMicrothreads()
         {
-            var scheduler = new Scheduler();
+            using var scheduler = new Scheduler();
             var microThreadLock = new MicroThreadLock();
             var counter = 0;
             for (var j = 0; j < ThreadCount; ++j)
@@ -48,7 +48,7 @@ public void TestConcurrencyInMicrothreads()
         [Fact]
         public void TestSequentialLocksInMicrothreads()
         {
-            var scheduler = new Scheduler();
+            using var scheduler = new Scheduler();
             var microThreadLock = new MicroThreadLock();
             var counter = 0;
             for (var j = 0; j < ThreadCount; ++j)
@@ -88,7 +88,7 @@ public void TestSequentialLocksInMicrothreads()
         [Fact]
         public void TestReentrancyInMicrothreads()
         {
-            var scheduler = new Scheduler();
+            using var scheduler = new Scheduler();
             var microThreadLock = new MicroThreadLock();
             var counter = 0;
             for (var j = 0; j < ThreadCount; ++j)
@@ -363,7 +363,7 @@ public void TestReentrancyInTasks()
         [Fact]
         public void TestConcurrencyInThreadsAndMicrothreads()
         {
-            var scheduler = new Scheduler();
+            using var scheduler = new Scheduler();
             var microThreadLock = new MicroThreadLock();
             var counter = 0;
             for (var j = 0; j < ThreadCount; ++j)
@@ -421,7 +421,7 @@ public void TestConcurrencyInThreadsAndMicrothreads()
         [Fact]
         public void TestConcurrencyInTasksAndMicrothreads()
         {
-            var scheduler = new Scheduler();
+            using var scheduler = new Scheduler();
             var microThreadLock = new MicroThreadLock();
             var counter = 0;
             for (var j = 0; j < ThreadCount; ++j)

sources/core/Stride.Core.MicroThreading/AsyncAutoResetEvent.cs

@@ -1,47 +1,43 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
-using System.Collections.Generic;
-using System.Threading.Tasks;
 
-namespace Stride.Core.MicroThreading
+namespace Stride.Core.MicroThreading;
+
+public class AsyncAutoResetEvent
 {
-    public class AsyncAutoResetEvent
-    {
-        // Credit: http://blogs.msdn.com/b/pfxteam/archive/2012/02/11/10266923.aspx
-        private static readonly Task Completed = Task.FromResult(true);
-        private readonly Queue<TaskCompletionSource<bool>> waits = new Queue<TaskCompletionSource<bool>>();
-        private bool signaled;
+    // Credit: http://blogs.msdn.com/b/pfxteam/archive/2012/02/11/10266923.aspx
+    private readonly Queue<TaskCompletionSource<bool>> waits = [];
+    private bool signaled;
 
-        public Task WaitAsync()
+    public Task WaitAsync()
+    {
+        lock (waits)
         {
-            lock (waits)
+            if (signaled)
+            {
+                signaled = false;
+                return Task.CompletedTask;
+            }
+            else
             {
-                if (signaled)
-                {
-                    signaled = false;
-                    return Completed;
-                }
-                else
-                {
-                    var tcs = new TaskCompletionSource<bool>();
-                    waits.Enqueue(tcs);
-                    return tcs.Task;
-                }
+                var tcs = new TaskCompletionSource<bool>();
+                waits.Enqueue(tcs);
+                return tcs.Task;
             }
         }
+    }
 
-        public void Set()
+    public void Set()
+    {
+        TaskCompletionSource<bool>? toRelease = null;
+        lock (waits)
         {
-            TaskCompletionSource<bool> toRelease = null;
-            lock (waits)
-            {
-                if (waits.Count > 0)
-                    toRelease = waits.Dequeue();
-                else if (!signaled)
-                    signaled = true;
-            }
-            if (toRelease != null)
-                toRelease.SetResult(true);
+            if (waits.Count > 0)
+                toRelease = waits.Dequeue();
+            else if (!signaled)
+                signaled = true;
         }
+
+        toRelease?.SetResult(true);
     }
 }

sources/core/Stride.Core.MicroThreading/AsyncSignal.cs

@@ -1,30 +1,27 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
-using System.Collections.Generic;
-using System.Threading.Tasks;
 
-namespace Stride.Core.MicroThreading
+namespace Stride.Core.MicroThreading;
+
+public class AsyncSignal
 {
-    public class AsyncSignal
-    {
-        private TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
+    private TaskCompletionSource<bool> tcs = new();
+    private readonly object lockObject = new();
 
-        public Task WaitAsync()
+    public Task WaitAsync()
+    {
+        lock (lockObject)
         {
-            lock (this)
-            {
-                tcs = new TaskCompletionSource<bool>();
-                var result = tcs.Task;
-                return result;
-            }
+            tcs = new TaskCompletionSource<bool>();
+            return tcs.Task;
         }
+    }
 
-        public void Set()
+    public void Set()
+    {
+        lock (lockObject)
         {
-            lock (this)
-            {
-                tcs.TrySetResult(true);
-            }
+            tcs.TrySetResult(true);
         }
     }
 }

sources/core/Stride.Core.MicroThreading/Channel.cs

@@ -1,117 +1,109 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
+namespace Stride.Core.MicroThreading;
 
-namespace Stride.Core.MicroThreading
+/// <summary>
+/// Provides a communication mechanism between <see cref="MicroThread"/>.
+/// </summary>
+/// <remarks>
+/// <see cref="MicroThread"/> can send and receive to a <see cref="Channel{T}"/>. Depending on the <see cref="Channel{T}.Preference"/>,
+/// sending or receiving <see cref="MicroThread"/> might be suspended and yield execution to another <see cref="MicroThread"/>.
+/// </remarks>
+/// <typeparam name="T">The type of element handled by this channel.</typeparam>
+// TODO: Thread-safety
+public class Channel<T>
 {
+    private readonly Queue<ChannelMicroThreadAwaiter<T>> receivers = [];
+    private readonly Queue<ChannelMicroThreadAwaiter<T>> senders = [];
+
+    public Channel()
+    {
+        Preference = ChannelPreference.PreferReceiver;
+    }
+
+    public void Reset()
+    {
+        receivers.Clear();
+        senders.Clear();
+    }
+
+    /// <summary>
+    /// Gets or sets the preference, allowing you to customize how <see cref="Send"/> and <see cref="Receive"/> behave regarding scheduling.
+    /// </summary>
+    /// <value>
+    /// The preference.
+    /// </value>
+    public ChannelPreference Preference { get; set; }
+
+    /// <summary>
+    /// Gets the balance, which is the number of <see cref="MicroThread"/> waiting to send (if greater than 0) or receive (if smaller than 0).
+    /// </summary>
+    /// <value>
+    /// The balance.
+    /// </value>
+    public int Balance { get { return senders.Count - receivers.Count; } }
+
     /// <summary>
-    /// Provides a communication mechanism between <see cref="MicroThread"/>.
+    /// Sends a value over the channel. If no other <see cref="MicroThread"/> is waiting for data, the sender will be blocked.
+    /// If someone was waiting for data, which of the sender or receiver continues next depends on <see cref="Preference"/>.
     /// </summary>
-    /// <remarks>
-    /// <see cref="MicroThread"/> can send and receive to a <see cref="Channel{T}"/>. Depending on the <see cref="Channel{T}.Preference"/>,
-    /// sending or receiving <see cref="MicroThread"/> might be suspended and yield execution to another <see cref="MicroThread"/>.
-    /// </remarks>
-    /// <typeparam name="T">The type of element handled by this channel.</typeparam>
-    // TODO: Thread-safety
-    public class Channel<T>
+    /// <param name="data">The data.</param>
+    /// <returns>Awaitable data.</returns>
+    public ChannelMicroThreadAwaiter<T> Send(T data)
     {
-        private readonly Queue<ChannelMicroThreadAwaiter<T>> receivers = new Queue<ChannelMicroThreadAwaiter<T>>();
-        private readonly Queue<ChannelMicroThreadAwaiter<T>> senders = new Queue<ChannelMicroThreadAwaiter<T>>();
-        
-        public Channel()
+        if (receivers.Count == 0)
         {
-            Preference = ChannelPreference.PreferReceiver;
+            // Nobody receiving, let's wait until something comes up
+            var microThread = MicroThread.Current;
+            var waitingMicroThread = ChannelMicroThreadAwaiter<T>.New(microThread);
+            waitingMicroThread.Result = data;
+            senders.Enqueue(waitingMicroThread);
+            return waitingMicroThread;
         }
 
-        public void Reset()
+        var receiver = receivers.Dequeue();
+        receiver.Result = data;
+        if (Preference == ChannelPreference.PreferSender)
         {
-            receivers.Clear();
-            senders.Clear();
+            receiver.MicroThread.ScheduleContinuation(ScheduleMode.Last, receiver.Continuation);
         }
-
-        /// <summary>
-        /// Gets or sets the preference, allowing you to customize how <see cref="Send"/> and <see cref="Receive"/> behave regarding scheduling.
-        /// </summary>
-        /// <value>
-        /// The preference.
-        /// </value>
-        public ChannelPreference Preference { get; set; }
-
-        /// <summary>
-        /// Gets the balance, which is the number of <see cref="MicroThread"/> waiting to send (if greater than 0) or receive (if smaller than 0).
-        /// </summary>
-        /// <value>
-        /// The balance.
-        /// </value>
-        public int Balance { get { return senders.Count - receivers.Count; } }
-
-        /// <summary>
-        /// Sends a value over the channel. If no other <see cref="MicroThread"/> is waiting for data, the sender will be blocked.
-        /// If someone was waiting for data, which of the sender or receiver continues next depends on <see cref="Preference"/>.
-        /// </summary>
-        /// <param name="data">The data.</param>
-        /// <returns>Awaitable data.</returns>
-        public ChannelMicroThreadAwaiter<T> Send(T data)
+        else if (Preference == ChannelPreference.PreferReceiver)
         {
-            if (receivers.Count == 0)
-            {
-                // Nobody receiving, let's wait until something comes up
-                var microThread = MicroThread.Current;
-                var waitingMicroThread = ChannelMicroThreadAwaiter<T>.New(microThread);
-                waitingMicroThread.Result = data;
-                senders.Enqueue(waitingMicroThread);
-                return waitingMicroThread;
-            }
-
-            var receiver = receivers.Dequeue();
-            receiver.Result = data;
-            if (Preference == ChannelPreference.PreferSender)
-            {
-                receiver.MicroThread.ScheduleContinuation(ScheduleMode.Last, receiver.Continuation);
-            }
-            else if (Preference == ChannelPreference.PreferReceiver)
-            {
-                receiver.MicroThread.ScheduleContinuation(ScheduleMode.First, receiver.Continuation);
-                throw new NotImplementedException();
-                //await Scheduler.Yield();
-            }
-            receiver.IsCompleted = true;
-            return receiver;
+            receiver.MicroThread.ScheduleContinuation(ScheduleMode.First, receiver.Continuation);
+            throw new NotImplementedException();
+            //await Scheduler.Yield();
         }
+        receiver.IsCompleted = true;
+        return receiver;
+    }
 
-        /// <summary>
-        /// Receives a value over the channel. If no other <see cref="MicroThread"/> is sending data, the receiver will be blocked.
-        /// If someone was sending data, which of the sender or receiver continues next depends on <see cref="Preference"/>.
-        /// </summary>
-        /// <returns>Awaitable data.</returns>
-        public ChannelMicroThreadAwaiter<T> Receive()
+    /// <summary>
+    /// Receives a value over the channel. If no other <see cref="MicroThread"/> is sending data, the receiver will be blocked.
+    /// If someone was sending data, which of the sender or receiver continues next depends on <see cref="Preference"/>.
+    /// </summary>
+    /// <returns>Awaitable data.</returns>
+    public ChannelMicroThreadAwaiter<T> Receive()
+    {
+        if (senders.Count == 0)
         {
-            if (senders.Count == 0)
-            {
-                var microThread = MicroThread.Current;
-                if (microThread == null)
-                    throw new Exception("Cannot receive out of micro-thread context.");
-
-                var waitingMicroThread = ChannelMicroThreadAwaiter<T>.New(microThread);
-                receivers.Enqueue(waitingMicroThread);
-                return waitingMicroThread;
-            }
+            var microThread = MicroThread.Current ?? throw new Exception("Cannot receive out of micro-thread context.");
+            var waitingMicroThread = ChannelMicroThreadAwaiter<T>.New(microThread);
+            receivers.Enqueue(waitingMicroThread);
+            return waitingMicroThread;
+        }
 
-            var sender = senders.Dequeue();
-            if (Preference == ChannelPreference.PreferReceiver)
-            {
-                sender.MicroThread.ScheduleContinuation(ScheduleMode.Last, sender.Continuation);
-            }
-            else if (Preference == ChannelPreference.PreferSender)
-            {
-                sender.MicroThread.ScheduleContinuation(ScheduleMode.First, sender.Continuation);
-                throw new NotImplementedException();
-                //await Scheduler.Yield();
-            }
-            sender.IsCompleted = true;
-            return sender;
+        var sender = senders.Dequeue();
+        if (Preference == ChannelPreference.PreferReceiver)
+        {
+            sender.MicroThread.ScheduleContinuation(ScheduleMode.Last, sender.Continuation);
+        }
+        else if (Preference == ChannelPreference.PreferSender)
+        {
+            sender.MicroThread.ScheduleContinuation(ScheduleMode.First, sender.Continuation);
+            throw new NotImplementedException();
+            //await Scheduler.Yield();
         }
+        sender.IsCompleted = true;
+        return sender;
     }
 }