Apparently it is completely broken on linux

.vscode/launch.json

@@ -98,7 +98,7 @@
             "type": "cppvsdbg",
             "request": "launch",
             "program": "${workspaceRoot}/bin/Debug/Seele_unit_tests.exe",
-            "args": ["--detect_memory_leaks=15533"],
+            "args": ["--detect_memory_leaks"],
             "stopAtEntry": false,
             "console": "integratedTerminal",
             "cwd": "${workspaceRoot}/bin/Debug",

src/Engine/Scene/Scene.cpp

@@ -48,19 +48,19 @@ Job Scene::beginUpdate(double deltaTime)
 {
     //std::cout << "Scene::beginUpdate" << std::endl;
     auto startTime = std::chrono::high_resolution_clock::now();
-    Array<Job> jobs;
+    //Array<Job> jobs;
     for(auto actor : rootActors)
     {
-        jobs.addAll(actor->launchTick(static_cast<float>(deltaTime)));
+        co_await Job::all(actor->launchTick(static_cast<float>(deltaTime)));
     }
-    co_await Job::all(jobs);
+    //co_await Job::all(std::move(jobs));
     auto endTime = std::chrono::high_resolution_clock::now();
-    float delta = std::chrono::duration_cast<std::chrono::seconds>(endTime - startTime).count();
+    float delta = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
     lastUpdate += delta;
     numUpdates++;
-    if(lastUpdate > 1.0f)
+    if(lastUpdate > 1000.0f)
     {
-        lastUpdate -= 1.0f;
+        lastUpdate -= 1000.0f;
         std::cout << numUpdates << " updates per second" << std::endl;
         numUpdates = 0;
     }
@@ -69,12 +69,12 @@ Job Scene::beginUpdate(double deltaTime)
 Job Scene::commitUpdate() 
 {
     //std::cout << "Scene::commitUpdate" << std::endl;
-    Array<Job> jobs;
+    //std::vector<Job> jobs;
     for(auto actor : rootActors)
     {
-        jobs.addAll(actor->launchUpdate());
+        co_await Job::all(actor->launchUpdate());
     }
-    co_await Job::all(jobs);
+    //co_await Job::all(std::move(jobs));
     //std::cout << "Scene::commitUpdate finished waiting" << std::endl;
 }
 

src/Engine/ThreadPool.cpp

@@ -62,10 +62,12 @@ void Event::raise()
     if(state->waitingJobs.size() > 0)
     {
         getGlobalThreadPool().scheduleBatch(state->waitingJobs);
+        state->waitingJobs.clear();
     }
     if(state->waitingMainJobs.size() > 0)
     {
         getGlobalThreadPool().scheduleBatch(state->waitingMainJobs);
+        state->waitingMainJobs.clear();
     }
 }
 void Event::reset()
@@ -87,14 +89,12 @@ bool Event::await_ready()
 
 void Event::await_suspend(std::coroutine_handle<JobPromiseBase<false>> h)
 {
-    //h.promise().enqueue(this);
     state->waitingJobs.add(JobBase<false>(&h.promise()));
     eventLock.unlock();
 }
 
 void Event::await_suspend(std::coroutine_handle<JobPromiseBase<true>> h)
 {
-    //h.promise().enqueue(this);
     state->waitingMainJobs.add(JobBase<true>(&h.promise()));
     eventLock.unlock();
 }

src/Engine/ThreadPool.h

@@ -308,7 +308,8 @@ public:
     template<typename... Awaitable>
     static JobBase all(Awaitable... jobs)
     {
-        return JobBase::all(std::initializer_list{jobs...});
+        std::vector vec{jobs...};
+        return std::move(JobBase::all(std::move(vec)));
     }
     template<typename JobFunc, std::ranges::input_range Iterable>
     requires std::invocable<JobFunc, std::ranges::range_reference_t<Iterable>>
@@ -338,9 +339,9 @@ public:
         std::scoped_lock lock(mainJobLock);
         for(auto job : jobs)
         {
-            //job.promise->addRef();
+            job.promise->validate();
             job.promise->state = JobPromiseBase<true>::State::SCHEDULED;
-            mainJobs.add(std::move(job));
+            mainJobs.add(job);
         }
         mainJobCV.notify_one();
     }
@@ -351,9 +352,9 @@ public:
         std::scoped_lock lock(jobQueueLock);
         for(auto job : jobs)
         {
-            //job.promise->addRef();
+            job.promise->validate();
             job.promise->state = JobPromiseBase<false>::State::SCHEDULED;
-            jobQueue.add(std::move(job));
+            jobQueue.add(job);
         }
         jobQueueCV.notify_all();
     }
@@ -426,6 +427,7 @@ inline JobBase<MainJob> JobBase<MainJob>::all(Iterable collection)
     {
         co_await it;
     }
+    collection.clear();
 }
 template<bool MainJob>
 template<typename JobFunc, std::ranges::input_range Iterable>

src/Engine/Window/WindowManager.h

@@ -11,7 +11,6 @@ class WindowManager
 public:
 	WindowManager();
 	~WindowManager();
-	Job init();
 	PWindow addWindow(const WindowCreateInfo &createInfo);
 	void notifyWindowClosed(PWindow window);
 	static Gfx::PGraphics getGraphics()

src/Engine/main.cpp

@@ -8,35 +8,167 @@ using namespace Seele;
 
 int main()
 {
-	PWindowManager windowManager = new WindowManager();
+    PWindowManager windowManager = new WindowManager();
-	AssetRegistry::init("C:\\Users\\Dynamitos\\TestSeeleProject");
+    AssetRegistry::init("C:\\Users\\Dynamitos\\TestSeeleProject");
-	WindowCreateInfo mainWindowInfo;
+    WindowCreateInfo mainWindowInfo;
-	mainWindowInfo.title = "SeeleEngine";
+    mainWindowInfo.title = "SeeleEngine";
-	mainWindowInfo.width = 1280;
+    mainWindowInfo.width = 1280;
-	mainWindowInfo.height = 720;
+    mainWindowInfo.height = 720;
-	mainWindowInfo.bFullscreen = false;
+    mainWindowInfo.bFullscreen = false;
-	mainWindowInfo.numSamples = 1;
+    mainWindowInfo.numSamples = 1;
-	mainWindowInfo.pixelFormat = Gfx::SE_FORMAT_B8G8R8A8_UNORM;
+    mainWindowInfo.pixelFormat = Gfx::SE_FORMAT_B8G8R8A8_UNORM;
-	auto window = windowManager->addWindow(mainWindowInfo);
+    auto window = windowManager->addWindow(mainWindowInfo);
-	ViewportCreateInfo sceneViewInfo;
+    ViewportCreateInfo sceneViewInfo;
-	sceneViewInfo.sizeX = 1280;
+    sceneViewInfo.sizeX = 1280;
-	sceneViewInfo.sizeY = 720;
+    sceneViewInfo.sizeY = 720;
-	sceneViewInfo.offsetX = 0;
+    sceneViewInfo.offsetX = 0;
-	sceneViewInfo.offsetY = 0;
+    sceneViewInfo.offsetY = 0;
-	PSceneView sceneView = new SceneView(windowManager->getGraphics(), window, sceneViewInfo);
+    PSceneView sceneView = new SceneView(windowManager->getGraphics(), window, sceneViewInfo);
-	window->addView(sceneView);
+    window->addView(sceneView);
-	
+    
-	ViewportCreateInfo inspectorViewInfo;
+    ViewportCreateInfo inspectorViewInfo;
-	inspectorViewInfo.sizeX = 640;
+    inspectorViewInfo.sizeX = 640;
-	inspectorViewInfo.sizeY = 720;
+    inspectorViewInfo.sizeY = 720;
-	inspectorViewInfo.offsetX = 640;
+    inspectorViewInfo.offsetX = 640;
-	inspectorViewInfo.offsetY = 0;
+    inspectorViewInfo.offsetY = 0;
-	//PInspectorView inspectorView = new InspectorView(windowManager->getGraphics(), window, inspectorViewInfo);
+    //PInspectorView inspectorView = new InspectorView(windowManager->getGraphics(), window, inspectorViewInfo);
-	//window->addView(inspectorView);
+    //window->addView(inspectorView);
-	sceneView->setFocused();
+    sceneView->setFocused();
 
-	window->render();
+    window->render();
-	
+    
-	getGlobalThreadPool().mainLoop();
+    getGlobalThreadPool().mainLoop();
-	return 0;
+    return 0;
-}
+}
+/*
+#include <coroutine>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+struct Return;
+struct Promise
+{
+    Promise()
+    {
+        handle = std::coroutine_handle<Promise>::from_promise(*this);
+        numRefs = 0;
+    }
+    Return get_return_object();
+    std::suspend_always initial_suspend() noexcept { return {}; }
+    std::suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() {}
+    void resume() { handle.resume(); }
+    void addRef()
+    {
+        numRefs++;
+    }
+    void removeRef()
+    {
+        numRefs--;
+        if(numRefs == 0)
+        {
+            if(handle.done())
+            {
+                handle.destroy();
+            }
+            else
+            {
+                resume();
+            }
+        }
+    }
+    std::coroutine_handle<Promise> handle;
+    uint64_t numRefs;
+};
+
+struct Return
+{
+    using promise_type = Promise;
+    Return(Promise* promise)
+        : promise(promise)
+    {
+        promise->addRef();
+    }
+    Return(const Return& other)
+    {
+        promise = other.promise;
+        if(promise != nullptr)
+        {
+            promise->addRef();
+        }
+    }
+    Return(Return&& other)
+    {
+        promise = other.promise;
+        other.promise = nullptr;
+    }
+    ~Return()
+    {
+        promise->removeRef();
+    }
+    Return& operator=(const Return& other)
+    {
+        if(this != &other)
+        {
+            if(promise != nullptr)
+            {
+                promise->removeRef();
+            }
+            promise = other.promise;
+            if(promise != nullptr)
+            {
+                promise->addRef();
+            }
+        }
+        return *this;
+    }
+    Return& operator=(Return&& other)
+    {
+        if(this != &other)
+        {
+            if(promise != nullptr)
+            {
+                promise->removeRef();
+            }
+            promise = other.promise;
+        }
+    }
+    Promise* promise;
+};
+
+
+Return Promise::get_return_object(){ 
+    return {this}; 
+}
+
+Return coro1()
+{
+    std::cout << "coro1" << std::endl;
+    co_return;
+}
+
+Return coro2()
+{
+    std::cout << "coro2" << std::endl;
+    co_return;
+}
+
+Return coroAll(std::vector<Return> coros)
+{
+    for(auto coro : coros)
+    {
+        coro.promise->resume();
+    }
+    co_return;
+}
+
+int main()
+{
+    std::vector<Return> returns{coro1(), coro2()};
+    std::thread t = std::thread([returns](){
+        coroAll(returns);
+    });
+    t.join();
+}*/

test/Engine/ThreadPool.cpp

@@ -7,6 +7,7 @@ using namespace std::chrono_literals;
 
 BOOST_AUTO_TEST_SUITE(ThreadPool)
 
+/*
 uint64 basicAwaitState = 0;
 
 Job basicAwaitFirst()
@@ -99,7 +100,7 @@ BOOST_AUTO_TEST_CASE(basic_thenchain)
             co_return;
         });
 }
-
+*/
 uint64 basicAllState1 = 0;
 uint64 basicAllState2 = 0;
 Job basicAllFirst()
@@ -123,9 +124,10 @@ Job basicAllThen()
 
 BOOST_AUTO_TEST_CASE(basic_all)
 {
-    Job::all(basicAllFirst(), basicAllSecond()).then(basicAllThen());
+    Job allJob = Job::all(basicAllFirst(), basicAllSecond());
+    allJob.then(basicAllThen());
 }
-
+/*
 uint64 allThenState = 0;
 
 Job allThenInitial()
@@ -213,6 +215,6 @@ Job launchStressTest()
 BOOST_AUTO_TEST_CASE(stress_test)
 {
     launchStressTest();
-}
+}*/
 
 BOOST_AUTO_TEST_SUITE_END()