1 files changed, 40 insertions, 70 deletions

diff --git a/src/common/fiber.cpp b/src/common/fiber.cpp
index 4f0f2b6430..ea3da3d053 100644
--- a/src/common/fiber.cpp
+++ b/src/common/fiber.cpp
@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <thread>
 #include <mutex>
 
 #include "common/assert.h"
@@ -14,100 +15,70 @@
 
 namespace Common {
 
-constexpr std::size_t default_stack_size = 512 * 1024;
+constexpr size_t DEFAULT_STACK_SIZE = 128 * 4096;
+constexpr u32 CANARY_VALUE = 0xDEADBEEF;
 
 struct Fiber::FiberImpl {
-    FiberImpl() : stack{default_stack_size}, rewind_stack{default_stack_size} {}
+    FiberImpl() {}
 
-    VirtualBuffer<u8> stack;
-    VirtualBuffer<u8> rewind_stack;
+    std::array<u8, DEFAULT_STACK_SIZE> stack{};
+    std::array<u8, DEFAULT_STACK_SIZE> rewind_stack{};
+    u32 canary = CANARY_VALUE;
+
+    boost::context::detail::fcontext_t context{};
+    boost::context::detail::fcontext_t rewind_context{};
 
     std::mutex guard;
     std::function<void()> entry_point;
     std::function<void()> rewind_point;
     std::shared_ptr<Fiber> previous_fiber;
-    bool is_thread_fiber{};
-    bool released{};
 
-    u8* stack_limit{};
-    u8* rewind_stack_limit{};
-    boost::context::detail::fcontext_t context{};
-    boost::context::detail::fcontext_t rewind_context{};
+    u8* stack_limit = nullptr;
+    u8* rewind_stack_limit = nullptr;
+    bool is_thread_fiber = false;
+    bool released = false;
 };
 
 void Fiber::SetRewindPoint(std::function<void()>&& rewind_func) {
     impl->rewind_point = std::move(rewind_func);
 }
 
-void Fiber::Start(boost::context::detail::transfer_t& transfer) {
-    ASSERT(impl->previous_fiber != nullptr);
-    impl->previous_fiber->impl->context = transfer.fctx;
-    impl->previous_fiber->impl->guard.unlock();
-    impl->previous_fiber.reset();
-    impl->entry_point();
-    UNREACHABLE();
-}
-
-void Fiber::OnRewind([[maybe_unused]] boost::context::detail::transfer_t& transfer) {
-    ASSERT(impl->context != nullptr);
-    impl->context = impl->rewind_context;
-    impl->rewind_context = nullptr;
-    u8* tmp = impl->stack_limit;
-    impl->stack_limit = impl->rewind_stack_limit;
-    impl->rewind_stack_limit = tmp;
-    impl->rewind_point();
-    UNREACHABLE();
-}
-
-void Fiber::FiberStartFunc(boost::context::detail::transfer_t transfer) {
-    auto* fiber = static_cast<Fiber*>(transfer.data);
-    fiber->Start(transfer);
-}
-
-void Fiber::RewindStartFunc(boost::context::detail::transfer_t transfer) {
-    auto* fiber = static_cast<Fiber*>(transfer.data);
-    fiber->OnRewind(transfer);
-}
-
 Fiber::Fiber(std::function<void()>&& entry_point_func) : impl{std::make_unique<FiberImpl>()} {
     impl->entry_point = std::move(entry_point_func);
     impl->stack_limit = impl->stack.data();
     impl->rewind_stack_limit = impl->rewind_stack.data();
-    u8* stack_base = impl->stack_limit + default_stack_size;
-    impl->context =
-        boost::context::detail::make_fcontext(stack_base, impl->stack.size(), FiberStartFunc);
+    u8* stack_base = impl->stack_limit + DEFAULT_STACK_SIZE;
+    impl->context = boost::context::detail::make_fcontext(stack_base, impl->stack.size(), [](boost::context::detail::transfer_t transfer) -> void {
+        auto* fiber = static_cast<Fiber*>(transfer.data);
+        ASSERT(fiber && fiber->impl && fiber->impl->previous_fiber && fiber->impl->previous_fiber->impl);
+        ASSERT(fiber->impl->canary == CANARY_VALUE);
+        fiber->impl->previous_fiber->impl->context = transfer.fctx;
+        fiber->impl->previous_fiber->impl->guard.unlock();
+        fiber->impl->previous_fiber.reset();
+        fiber->impl->entry_point();
+        UNREACHABLE();
+    });
 }
 
 Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
 
 Fiber::~Fiber() {
-    if (impl->released) {
-        return;
-    }
-    // Make sure the Fiber is not being used
-    const bool locked = impl->guard.try_lock();
-    ASSERT_MSG(locked, "Destroying a fiber that's still running");
-    if (locked) {
-        impl->guard.unlock();
+    if (!impl->released) {
+        // Make sure the Fiber is not being used
+        const bool locked = impl->guard.try_lock();
+        ASSERT_MSG(locked, "Destroying a fiber that's still running");
+        if (locked) {
+            impl->guard.unlock();
+        }
     }
 }
 
 void Fiber::Exit() {
     ASSERT_MSG(impl->is_thread_fiber, "Exiting non main thread fiber");
-    if (!impl->is_thread_fiber) {
-        return;
+    if (impl->is_thread_fiber) {
+        impl->guard.unlock();
+        impl->released = true;
     }
-    impl->guard.unlock();
-    impl->released = true;
-}
-
-void Fiber::Rewind() {
-    ASSERT(impl->rewind_point);
-    ASSERT(impl->rewind_context == nullptr);
-    u8* stack_base = impl->rewind_stack_limit + default_stack_size;
-    impl->rewind_context =
-        boost::context::detail::make_fcontext(stack_base, impl->stack.size(), RewindStartFunc);
-    boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }
 
 void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
@@ -115,16 +86,15 @@ void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
     to.impl->previous_fiber = weak_from.lock();
 
     auto transfer = boost::context::detail::jump_fcontext(to.impl->context, &to);
-
     // "from" might no longer be valid if the thread was killed
     if (auto from = weak_from.lock()) {
         if (from->impl->previous_fiber == nullptr) {
-            ASSERT_MSG(false, "previous_fiber is nullptr!");
-            return;
+            ASSERT(false && "previous_fiber is nullptr!");
+        } else {
+            from->impl->previous_fiber->impl->context = transfer.fctx;
+            from->impl->previous_fiber->impl->guard.unlock();
+            from->impl->previous_fiber.reset();
         }
-        from->impl->previous_fiber->impl->context = transfer.fctx;
-        from->impl->previous_fiber->impl->guard.unlock();
-        from->impl->previous_fiber.reset();
     }
 }