Removed some locks sind Scheduler isn't thread-safe anyways

include/scheduled_thread.hpp

@@ -12,6 +12,8 @@
 
 namespace CoSched {
 class ScheduledThread {
+    static thread_local ScheduledThread *current;
+
     struct QueueEntry {
         std::string task_name;
         std::function<AwaitableTask<void> ()> start_fcn;
@@ -30,14 +32,21 @@ class ScheduledThread {
 public:
     ScheduledThread() {}
 
+    // Current thread MUST be made by start()
+    inline static
+    ScheduledThread *get_current() {
+        return current;
+    }
+
     // MUST NOT already be running
     void start() {
         thread = std::thread([this] () {
+            current = this;
             main_loop();
         });
     }
 
-    // DO NOT call from within a task
+    // Cann be called from within a task
     void create_task(const std::string& task_name, std::function<AwaitableTask<void> ()>&& task_fcn) {
         // Enqueue function
         {

include/scheduler.hpp

@@ -3,7 +3,6 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
-#include <mutex>
 #include <memory>
 #include <chrono>
 #include <any>
@@ -113,7 +112,6 @@ class Scheduler {
     friend class Task;
     friend class TaskPtr;
 
-    std::mutex tasks_mutex;
     std::vector<std::unique_ptr<Task>> tasks;
 
     void clean_task(Task *task);
@@ -142,7 +140,6 @@ public:
         clean_task(Task::current);
 
         // Create and switch to new task
-        std::scoped_lock L(tasks_mutex);
         Task::current = tasks.emplace_back(std::make_unique<Task>(this, name)).get();
     }
 

scheduled_thread.cpp

@@ -2,18 +2,21 @@
 
 
 
-void CoSched::ScheduledThread::main_loop() {
+namespace CoSched {
+void ScheduledThread::main_loop() {
     // Create scheduler
     Scheduler sched;
     // Loop until shutdown is requested
     while (!shutdown_requested) {
         // Start all new tasks enqueued
         {
-            std::scoped_lock L(queue_mutex);
+            std::unique_lock L(queue_mutex);
             while (!queue.empty()) {
                 // Get queue entry
+                L.lock();
                 auto e = std::move(queue.front());
                 queue.pop();
+                L.unlock();
                 // Create task for it
                 sched.create_task(e.task_name);
                 // Move start function somewhere else
@@ -32,3 +35,7 @@ void CoSched::ScheduledThread::main_loop() {
         }
     }
 }
+
+
+thread_local ScheduledThread *ScheduledThread::current;
+}

scheduler.cpp

@@ -49,13 +49,10 @@ void Scheduler::clean_task(Task *task) {
 }
 
 void Scheduler::delete_task(Task *task) {
-    std::scoped_lock L(tasks_mutex);
     tasks.erase(std::find_if(tasks.begin(), tasks.end(), [task] (const auto& o) {return o.get() == task;}));
 }
 
 Task *Scheduler::get_next_task() {
-    std::scoped_lock L(tasks_mutex);
-
     // Get tasks with highest priority
     std::vector<Task*> max_prio_tasks;
     Priority max_prio = std::numeric_limits<Priority>::min();