Added docs.

Author: genaray

JobScheduler/JobHandle.cs

@@ -61,7 +61,7 @@ internal JobHandle RentJobHandle(IJob iJob)
             throw new("Job cannot be null");
         }
 
-        _freeIds.GetHandle(out var index);
+        _freeIds.RentHandle(out var index);
 
         if (index == null)
         {

JobScheduler/Utils/IParallelJobProducer.cs

@@ -122,13 +122,21 @@ public void Execute()
         }
     }
 
+    /// <summary>
+    /// Calculates the amount of children this job will split into.
+    /// </summary>
+    /// <returns>The amount.</returns>
     private int CalculateChildrenToSplitInto()
     {
         const int ChildrenToSplitInto = 128; //This should be equal to the number of threads(or that times 2/3?) but for now it's just a constant
         var range = _to - _from;
         return range < ChildrenToSplitInto ? range : ChildrenToSplitInto;
     }
 
+    /// <summary>
+    /// Checks and splits this instance into more instances.
+    /// </summary>
+    /// <returns>If a split occured</returns>
     private bool CheckAndSplit()
     {
         if (!_shouldSplitWhenAvailable || CalculateChildrenToSplitInto() <= 1)
@@ -141,6 +149,10 @@ private bool CheckAndSplit()
         return true;
     }
 
+    /// <summary>
+    /// Splits this instance into sub instances.
+    /// </summary>
+    /// <exception cref="Exception">An exception occuring when an invalid range was passed.</exception>
     private void Split()
     {
         var childrenToSplitInto = CalculateChildrenToSplitInto();

JobScheduler/Utils/JobHandlePool.cs

@@ -1,12 +1,20 @@
 namespace Schedulers.Utils;
 
+/// <summary>
+/// This <see cref="JobHandlePool"/> class
+/// acts as a pool for <see cref="JobHandle"/> ids.
+/// </summary>
 internal class JobHandlePool
 {
-    public readonly ushort[] _handles;
+    private readonly ushort[] _handles;
     private readonly bool[] _isFree;
     private readonly Queue<ushort> _freeHandles;
     private int _returnedHandles;
 
+    /// <summary>
+    /// Creates a new instance.
+    /// </summary>
+    /// <param name="size">Its initial size.</param>
     public JobHandlePool(int size)
     {
         _freeHandles = new(size);
@@ -21,36 +29,19 @@ public JobHandlePool(int size)
         }
     }
 
-    private void CleanupHandles()
-    {
-        // Prevent cleanup if no handles were returned
-        // This is a guard to prevent cleanup every time someone tries to get a handle, in a tight loop
-        if (_returnedHandles == 0)
-        {
-            return;
-        }
-
-        _freeHandles.Clear();
-        for (ushort i = 0; i < _isFree.Length; i++)
-        {
-            if (_isFree[i])
-            {
-                _freeHandles.Enqueue(i);
-            }
-        }
-
-        _returnedHandles = 0;
-    }
-
-    // Not intrinsically thread safe so we lock
-    // Assumption is that the user won't generate handles on other threads
-    internal bool GetHandle(out ushort? handle)
+    /// <summary>
+    /// Rents a new handle.
+    /// </summary>
+    /// <param name="handle">The rented handle.</param>
+    /// <remarks>Not intrinsically thread safe so we lock. Assumption is that the user won't generate handles on other threads</remarks>
+    /// <returns>True or false.</returns>
+    internal bool RentHandle(out ushort? handle)
     {
         lock (this)
         {
             if (_freeHandles.Count == 0)
             {
-                CleanupHandles();
+                Clear();
             }
 
             if (_freeHandles.Count == 0)
@@ -66,10 +57,39 @@ internal bool GetHandle(out ushort? handle)
         }
     }
 
-    //Thread safe
+    /// <summary>
+    /// Returns a rented handle.
+    /// </summary>
+    /// <param name="handle">The initial rented handle.</param>
+    /// <remarks>Thread safe.</remarks>
     internal void ReturnHandle(JobHandle handle)
     {
         _isFree[handle.Index] = true;
         _returnedHandles++; // We don't care about thread safety here
     }
+
+
+    /// <summary>
+    /// Clears this instance.
+    /// </summary>
+    private void Clear()
+    {
+        // Prevent cleanup if no handles were returned
+        // This is a guard to prevent cleanup every time someone tries to get a handle, in a tight loop
+        if (_returnedHandles == 0)
+        {
+            return;
+        }
+
+        _freeHandles.Clear();
+        for (ushort i = 0; i < _isFree.Length; i++)
+        {
+            if (_isFree[i])
+            {
+                _freeHandles.Enqueue(i);
+            }
+        }
+
+        _returnedHandles = 0;
+    }
 }