CMakeLists.txt

@@ -427,6 +427,8 @@ if (YUZU_USE_CPM)
             target_compile_options(boost_icl INTERFACE -Wno-shadow)
             target_compile_options(boost_asio INTERFACE -Wno-conversion -Wno-implicit-fallthrough)
         endif()
+    elseif (PLATFORM_LINUX OR APPLE)
+        find_package(Boost 1.57.0 REQUIRED headers context system fiber)
     endif()
 
     # fmt
@@ -488,7 +490,7 @@ else()
     find_package(zstd 1.5 REQUIRED MODULE)
 
     # wow
-    if (PLATFORM_LINUX)
+    if (PLATFORM_LINUX OR APPLE)
         find_package(Boost 1.57.0 REQUIRED headers context system fiber)
     else()
         find_package(Boost 1.57.0 REQUIRED)

src/common/CMakeLists.txt

@@ -260,6 +260,10 @@ else()
     target_link_libraries(common PUBLIC Boost::headers)
 endif()
 
+if (TARGET Boost::context)
+  target_link_libraries(common PUBLIC Boost::context)
+endif()
+
 if (lz4_ADDED)
     target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)
 endif()

src/common/fiber.cpp

@@ -5,47 +5,87 @@
 
 #include "common/assert.h"
 #include "common/fiber.h"
-#define MCO_USE_VMEM_ALLOCATOR
+#include "common/virtual_buffer.h"
-#define MINICORO_IMPL
+
-#include "common/minicoro.h"
+#include <boost/context/detail/fcontext.hpp>
 
 namespace Common {
 
+constexpr std::size_t default_stack_size = 512 * 1024;
+
 struct Fiber::FiberImpl {
-    FiberImpl() {}
+    FiberImpl() : stack{default_stack_size}, rewind_stack{default_stack_size} {}
+
+    VirtualBuffer<u8> stack;
+    VirtualBuffer<u8> rewind_stack;
 
     std::mutex guard;
-    bool released{};
-    bool is_thread_fiber{};
-    Fiber* next_fiber{};
-    Fiber** next_fiber_ptr;
     std::function<void()> entry_point;
+    std::function<void()> rewind_point;
+    std::shared_ptr<Fiber> previous_fiber;
+    bool is_thread_fiber{};
+    bool released{};
 
-    mco_coro* context;
+    u8* stack_limit{};
+    u8* rewind_stack_limit{};
+    boost::context::detail::fcontext_t context{};
+    boost::context::detail::fcontext_t rewind_context{};
 };
 
-Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {
+void Fiber::SetRewindPoint(std::function<void()>&& rewind_func) {
-    impl->is_thread_fiber = true;
+    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);
-    auto desc = mco_desc_init(
+    impl->stack_limit = impl->stack.data();
-        [](mco_coro* coro) { reinterpret_cast<Fiber*>(coro->user_data)->impl->entry_point(); }, 0);
+    impl->rewind_stack_limit = impl->rewind_stack.data();
-    desc.user_data = this;
+    u8* stack_base = impl->stack_limit + default_stack_size;
-    mco_result res = mco_create(&impl->context, &desc);
+    impl->context =
-    ASSERT(res == MCO_SUCCESS);
+        boost::context::detail::make_fcontext(stack_base, impl->stack.size(), FiberStartFunc);
 }
 
+Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
+
 Fiber::~Fiber() {
     if (impl->released) {
         return;
     }
-    DestroyPre();
+    // Make sure the Fiber is not being used
-    if (impl->is_thread_fiber) {
+    const bool locked = impl->guard.try_lock();
-        DestroyThreadFiber();
+    ASSERT_MSG(locked, "Destroying a fiber that's still running");
-    } else {
+    if (locked) {
-        DestroyWorkFiber();
+        impl->guard.unlock();
     }
 }
 
@@ -54,66 +94,42 @@ void Fiber::Exit() {
     if (!impl->is_thread_fiber) {
         return;
     }
-    DestroyPre();
+    impl->guard.unlock();
-    DestroyThreadFiber();
-}
-
-void Fiber::DestroyPre() {
-    // 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();
-    }
     impl->released = true;
 }
 
-void Fiber::DestroyWorkFiber() {
+void Fiber::Rewind() {
-    mco_result res = mco_destroy(impl->context);
+    ASSERT(impl->rewind_point);
-    ASSERT(res == MCO_SUCCESS);
+    ASSERT(impl->rewind_context == nullptr);
-}
+    u8* stack_base = impl->rewind_stack_limit + default_stack_size;
-
+    impl->rewind_context =
-void Fiber::DestroyThreadFiber() {
+        boost::context::detail::make_fcontext(stack_base, impl->stack.size(), RewindStartFunc);
-    if (*impl->next_fiber_ptr) {
+    boost::context::detail::jump_fcontext(impl->rewind_context, this);
-        *impl->next_fiber_ptr = nullptr;
-    }
 }
 
 void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
+    to.impl->guard.lock();
+    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->is_thread_fiber) {
+        if (from->impl->previous_fiber == nullptr) {
-            // Set next fiber
+            ASSERT_MSG(false, "previous_fiber is nullptr!");
-            from->impl->next_fiber = &to;
+            return;
-            // Yield from thread
-            if (!from->impl->released) {
-                from->impl->guard.unlock();
-                mco_yield(from->impl->context);
-            }
-        } else {
-            from->impl->guard.lock();
-            // Keep running next fiber until they've ran out
-            auto& next_fiber_ptr = from->impl->next_fiber_ptr;
-            next_fiber_ptr = &from->impl->next_fiber;
-            *next_fiber_ptr = &to;
-            for ([[maybe_unused]] unsigned round = 0; *next_fiber_ptr; round++) {
-                auto next = *next_fiber_ptr;
-                *next_fiber_ptr = nullptr;
-                next_fiber_ptr = &next->impl->next_fiber;
-                // Stop if new thread is thread fiber
-                if (next->impl->is_thread_fiber)
-                    break;
-                // Resume new thread
-                next->impl->guard.lock();
-                mco_result res = mco_resume(next->impl->context);
-                ASSERT(res == MCO_SUCCESS);
-            }
-            from->impl->guard.unlock();
         }
+        from->impl->previous_fiber->impl->context = transfer.fctx;
+        from->impl->previous_fiber->impl->guard.unlock();
+        from->impl->previous_fiber.reset();
     }
 }
 
 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
-    return std::shared_ptr<Fiber>{new Fiber()};
+    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
+    fiber->impl->guard.lock();
+    fiber->impl->is_thread_fiber = true;
+    return fiber;
 }
 
 } // namespace Common

src/common/fiber.h

@@ -6,7 +6,9 @@
 #include <functional>
 #include <memory>
 
-#include "common/minicoro.h"
+namespace boost::context::detail {
+struct transfer_t;
+}
 
 namespace Common {
 
@@ -36,18 +38,25 @@ public:
     Fiber(Fiber&&) = default;
     Fiber& operator=(Fiber&&) = default;
 
+    /// Yields control from Fiber 'from' to Fiber 'to'
+    /// Fiber 'from' must be the currently running fiber.
     static void YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to);
     [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
 
+    void SetRewindPoint(std::function<void()>&& rewind_func);
+
+    void Rewind();
+
     /// Only call from main thread's fiber
     void Exit();
 
 private:
     Fiber();
 
-    void DestroyPre();
+    void OnRewind(boost::context::detail::transfer_t& transfer);
-    void DestroyWorkFiber();
+    void Start(boost::context::detail::transfer_t& transfer);
-    void DestroyThreadFiber();
+    static void FiberStartFunc(boost::context::detail::transfer_t transfer);
+    static void RewindStartFunc(boost::context::detail::transfer_t transfer);
 
     struct FiberImpl;
     std::unique_ptr<FiberImpl> impl;