From bc82b2dc2f7405c0fd4d179830412ea8209137b1 Mon Sep 17 00:00:00 2001
From: Jake Mannens <jake@asger.xyz>
Date: Wed, 27 Sep 2023 03:38:58 +1000
Subject: Added MemoryCache class and implemented principal/ACL cache in the
 security service

---
 Util/LimitedConcurrencyTaskScheduler.cs | 88 +++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 Util/LimitedConcurrencyTaskScheduler.cs

(limited to 'Util/LimitedConcurrencyTaskScheduler.cs')

diff --git a/Util/LimitedConcurrencyTaskScheduler.cs b/Util/LimitedConcurrencyTaskScheduler.cs
new file mode 100644
index 0000000..8d5adf2
--- /dev/null
+++ b/Util/LimitedConcurrencyTaskScheduler.cs
@@ -0,0 +1,88 @@
+namespace HyperBooru.Util;
+
+public class LimitedConcurrencyTaskScheduler : TaskScheduler {
+    public sealed override int MaximumConcurrencyLevel =>
+        maxConcurrency;
+
+    private int maxConcurrency;
+
+    [ThreadStatic]
+    private static bool threadIsProcessingItems;
+
+    private readonly LinkedList<Task> tasks = new();
+
+    private int delegatesQueuedOrRunning = 0;
+
+    public LimitedConcurrencyTaskScheduler() {
+        maxConcurrency = Environment.ProcessorCount;
+    }
+
+    public LimitedConcurrencyTaskScheduler(int maxConcurrency) {
+        if(maxConcurrency < 1)
+            throw new ArgumentOutOfRangeException("maxConcurrency must be greater than 0");
+        this.maxConcurrency = (int) maxConcurrency;
+    }
+
+    protected sealed override void QueueTask(Task task) {
+        lock(tasks) {
+            tasks.AddLast(task);
+            if(delegatesQueuedOrRunning < maxConcurrency) {
+                delegatesQueuedOrRunning++;
+                NotifyThreadPoolOfPendingWork();
+            }
+        }
+    }
+
+    private void NotifyThreadPoolOfPendingWork() {
+        ThreadPool.UnsafeQueueUserWorkItem(_ => {
+            threadIsProcessingItems = true;
+            try {
+                while(true) {
+                    Task item;
+                    lock(tasks) {
+                        if(tasks.Count == 0) {
+                            delegatesQueuedOrRunning--;
+                            break;
+                        } else {
+                            item = tasks.First.Value;
+                            tasks.RemoveFirst();
+                        }
+                    }
+                    TryExecuteTask(item);
+                }
+            } finally {
+                threadIsProcessingItems = false;
+            }
+        }, null);
+    }
+
+    protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) {
+        if(!threadIsProcessingItems)
+            return false;
+
+        if(taskWasPreviouslyQueued)
+            return TryDequeue(task) ? TryExecuteTask(task) : false;
+        else
+            return TryExecuteTask(task);
+    }
+
+    protected sealed override bool TryDequeue(Task task) {
+        lock(tasks) {
+            return tasks.Remove(task);
+        }
+    }
+
+    protected sealed override IEnumerable<Task> GetScheduledTasks() {
+        bool lockTaken = false;
+        try {
+            Monitor.TryEnter(tasks, ref lockTaken);
+            if(lockTaken)
+                return tasks;
+            else
+                throw new NotSupportedException();
+        } finally {
+            if(lockTaken)
+                Monitor.Exit(tasks);
+        }
+    }
+}
-- 
cgit v1.3