From cd9434a867e6c875a0296c920c6c70ab6be7b613 Mon Sep 17 00:00:00 2001 From: pineappleEA Date: Sat, 19 Nov 2022 12:44:30 +0100 Subject: [PATCH] early-access version 3130 --- README.md | 2 +- src/audio_core/sink/sink_stream.cpp | 16 ++- src/common/fiber.cpp | 147 ++++++++++++++++++++++------ src/common/fiber.h | 16 ++- src/core/cpu_manager.cpp | 4 +- src/core/hle/kernel/k_scheduler.cpp | 6 +- src/tests/common/fibers.cpp | 28 +++--- 7 files changed, 165 insertions(+), 54 deletions(-) diff --git a/README.md b/README.md index ddadc47cd..6977601f9 100755 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ yuzu emulator early access ============= -This is the source code for early-access 3129. +This is the source code for early-access 3130. ## Legal Notice diff --git a/src/audio_core/sink/sink_stream.cpp b/src/audio_core/sink/sink_stream.cpp index 5d8a96009..89520c805 100755 --- a/src/audio_core/sink/sink_stream.cpp +++ b/src/audio_core/sink/sink_stream.cpp @@ -265,8 +265,20 @@ void SinkStream::ProcessAudioOutAndRender(std::span output_buffer, std::siz } } -void SinkStream::Stall() {} +void SinkStream::Stall() { + if (stalled) { + return; + } + stalled = true; + system.StallProcesses(); +} -void SinkStream::Unstall() {} +void SinkStream::Unstall() { + if (!stalled) { + return; + } + system.UnstallProcesses(); + stalled = false; +} } // namespace AudioCore::Sink diff --git a/src/common/fiber.cpp b/src/common/fiber.cpp index ebf7ff169..ed0b0b286 100755 --- a/src/common/fiber.cpp +++ b/src/common/fiber.cpp @@ -1,41 +1,133 @@ // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include - #include "common/assert.h" #include "common/fiber.h" -#include "common/virtual_buffer.h" +#include "common/spin_lock.h" +#if defined(_WIN32) || defined(WIN32) +#include +#else #include +#endif namespace Common { constexpr std::size_t default_stack_size = 512 * 1024; struct Fiber::FiberImpl { - FiberImpl() : stack{default_stack_size}, rewind_stack{default_stack_size} {} - - VirtualBuffer stack; - VirtualBuffer rewind_stack; - - std::mutex guard; + SpinLock guard{}; std::function entry_point; std::function rewind_point; + void* rewind_parameter{}; std::shared_ptr 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{}; +#if defined(_WIN32) || defined(WIN32) + LPVOID handle = nullptr; + LPVOID rewind_handle = nullptr; +#else + alignas(64) std::array stack; + alignas(64) std::array rewind_stack; + u8* stack_limit; + u8* rewind_stack_limit; + boost::context::detail::fcontext_t context; + boost::context::detail::fcontext_t rewind_context; +#endif }; void Fiber::SetRewindPoint(std::function&& rewind_func) { impl->rewind_point = std::move(rewind_func); } +#if defined(_WIN32) || defined(WIN32) + +void Fiber::Start() { + ASSERT(impl->previous_fiber != nullptr); + impl->previous_fiber->impl->guard.unlock(); + impl->previous_fiber.reset(); + impl->entry_point(); + UNREACHABLE(); +} + +void Fiber::OnRewind() { + ASSERT(impl->handle != nullptr); + DeleteFiber(impl->handle); + impl->handle = impl->rewind_handle; + impl->rewind_handle = nullptr; + impl->rewind_point(); + UNREACHABLE(); +} + +void Fiber::FiberStartFunc(void* fiber_parameter) { + auto* fiber = static_cast(fiber_parameter); + fiber->Start(); +} + +void Fiber::RewindStartFunc(void* fiber_parameter) { + auto* fiber = static_cast(fiber_parameter); + fiber->OnRewind(); +} + +Fiber::Fiber(std::function&& entry_point_func) : impl{std::make_unique()} { + impl->entry_point = std::move(entry_point_func); + impl->handle = CreateFiber(default_stack_size, &FiberStartFunc, this); +} + +Fiber::Fiber() : impl{std::make_unique()} {} + +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(); + } + DeleteFiber(impl->handle); +} + +void Fiber::Exit() { + ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber"); + if (!impl->is_thread_fiber) { + return; + } + ConvertFiberToThread(); + impl->guard.unlock(); + impl->released = true; +} + +void Fiber::Rewind() { + ASSERT(impl->rewind_point); + ASSERT(impl->rewind_handle == nullptr); + impl->rewind_handle = CreateFiber(default_stack_size, &RewindStartFunc, this); + SwitchToFiber(impl->rewind_handle); +} + +void Fiber::YieldTo(std::shared_ptr from, std::shared_ptr to) { + ASSERT_MSG(from != nullptr, "Yielding fiber is null!"); + ASSERT_MSG(to != nullptr, "Next fiber is null!"); + to->impl->guard.lock(); + to->impl->previous_fiber = from; + SwitchToFiber(to->impl->handle); + ASSERT(from->impl->previous_fiber != nullptr); + from->impl->previous_fiber->impl->guard.unlock(); + from->impl->previous_fiber.reset(); +} + +std::shared_ptr Fiber::ThreadToFiber() { + std::shared_ptr fiber = std::shared_ptr{new Fiber()}; + fiber->impl->guard.lock(); + fiber->impl->handle = ConvertThreadToFiber(nullptr); + fiber->impl->is_thread_fiber = true; + return fiber; +} + +#else + void Fiber::Start(boost::context::detail::transfer_t& transfer) { ASSERT(impl->previous_fiber != nullptr); impl->previous_fiber->impl->context = transfer.fctx; @@ -107,22 +199,16 @@ void Fiber::Rewind() { boost::context::detail::jump_fcontext(impl->rewind_context, this); } -void Fiber::YieldTo(std::weak_ptr 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->previous_fiber == nullptr) { - ASSERT_MSG(false, "previous_fiber is nullptr!"); - return; - } - from->impl->previous_fiber->impl->context = transfer.fctx; - from->impl->previous_fiber->impl->guard.unlock(); - from->impl->previous_fiber.reset(); - } +void Fiber::YieldTo(std::shared_ptr from, std::shared_ptr to) { + ASSERT_MSG(from != nullptr, "Yielding fiber is null!"); + ASSERT_MSG(to != nullptr, "Next fiber is null!"); + to->impl->guard.lock(); + to->impl->previous_fiber = from; + auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get()); + ASSERT(from->impl->previous_fiber != nullptr); + from->impl->previous_fiber->impl->context = transfer.fctx; + from->impl->previous_fiber->impl->guard.unlock(); + from->impl->previous_fiber.reset(); } std::shared_ptr Fiber::ThreadToFiber() { @@ -132,4 +218,5 @@ std::shared_ptr Fiber::ThreadToFiber() { return fiber; } -} // namespace Common +#endif +} // namespace Common \ No newline at end of file diff --git a/src/common/fiber.h b/src/common/fiber.h index 077d66f38..f03ef267c 100755 --- a/src/common/fiber.h +++ b/src/common/fiber.h @@ -6,9 +6,11 @@ #include #include +#if !defined(_WIN32) && !defined(WIN32) namespace boost::context::detail { struct transfer_t; } +#endif namespace Common { @@ -40,7 +42,7 @@ public: /// Yields control from Fiber 'from' to Fiber 'to' /// Fiber 'from' must be the currently running fiber. - static void YieldTo(std::weak_ptr weak_from, Fiber& to); + static void YieldTo(std::shared_ptr from, std::shared_ptr to); [[nodiscard]] static std::shared_ptr ThreadToFiber(); void SetRewindPoint(std::function&& rewind_func); @@ -50,16 +52,26 @@ public: /// Only call from main thread's fiber void Exit(); + /// Changes the start parameter of the fiber. Has no effect if the fiber already started + void SetStartParameter(void* new_parameter); + private: Fiber(); +#if defined(_WIN32) || defined(WIN32) + void OnRewind(); + void Start(); + static void FiberStartFunc(void* fiber_parameter); + static void RewindStartFunc(void* fiber_parameter); +#else void OnRewind(boost::context::detail::transfer_t& transfer); void Start(boost::context::detail::transfer_t& transfer); static void FiberStartFunc(boost::context::detail::transfer_t transfer); static void RewindStartFunc(boost::context::detail::transfer_t transfer); +#endif struct FiberImpl; std::unique_ptr impl; }; -} // namespace Common +} // namespace Common \ No newline at end of file diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp index fef0b5131..100169b30 100755 --- a/src/core/cpu_manager.cpp +++ b/src/core/cpu_manager.cpp @@ -180,7 +180,7 @@ void CpuManager::ShutdownThread() { auto* thread = kernel.GetCurrentEmuThread(); auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0; - Common::Fiber::YieldTo(thread->GetHostContext(), *core_data[core].host_context); + Common::Fiber::YieldTo(thread->GetHostContext(), core_data[core].host_context); UNREACHABLE(); } @@ -217,7 +217,7 @@ void CpuManager::RunThread(std::size_t core) { auto* thread = scheduler.GetSchedulerCurrentThread(); Kernel::SetCurrentThread(kernel, thread); - Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext()); + Common::Fiber::YieldTo(data.host_context, thread->GetHostContext()); } } // namespace Core diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp index 4f6ec9059..977578cd5 100755 --- a/src/core/hle/kernel/k_scheduler.cpp +++ b/src/core/hle/kernel/k_scheduler.cpp @@ -116,7 +116,7 @@ void KScheduler::PreemptSingleCore() { auto& previous_scheduler = kernel.Scheduler(thread->GetCurrentCore()); previous_scheduler.Unload(thread); - Common::Fiber::YieldTo(thread->GetHostContext(), *m_switch_fiber); + Common::Fiber::YieldTo(thread->GetHostContext(), m_switch_fiber); GetCurrentThread(kernel).EnableDispatch(); } @@ -411,7 +411,7 @@ void KScheduler::ScheduleImpl() { m_switch_cur_thread = cur_thread; m_switch_highest_priority_thread = highest_priority_thread; m_switch_from_schedule = true; - Common::Fiber::YieldTo(cur_thread->host_context, *m_switch_fiber); + Common::Fiber::YieldTo(cur_thread->host_context, m_switch_fiber); // Returning from ScheduleImpl occurs after this thread has been scheduled again. } @@ -489,7 +489,7 @@ void KScheduler::ScheduleImplFiber() { Reload(highest_priority_thread); // Reload the host thread. - Common::Fiber::YieldTo(m_switch_fiber, *highest_priority_thread->host_context); + Common::Fiber::YieldTo(m_switch_fiber, highest_priority_thread->host_context); } void KScheduler::Unload(KThread* thread) { diff --git a/src/tests/common/fibers.cpp b/src/tests/common/fibers.cpp index 4a42dd3b6..50726e7a0 100755 --- a/src/tests/common/fibers.cpp +++ b/src/tests/common/fibers.cpp @@ -50,7 +50,7 @@ public: value++; } results[id] = value; - Fiber::YieldTo(work_fibers[id], *thread_fibers[id]); + Fiber::YieldTo(work_fibers[id], thread_fibers[id]); } void ExecuteThread(u32 id); @@ -68,7 +68,7 @@ void TestControl1::ExecuteThread(u32 id) { thread_fibers[id] = thread_fiber; work_fibers[id] = std::make_shared([this] { DoWork(); }); items[id] = rand() % 256; - Fiber::YieldTo(thread_fibers[id], *work_fibers[id]); + Fiber::YieldTo(thread_fibers[id], work_fibers[id]); thread_fibers[id]->Exit(); } @@ -105,11 +105,11 @@ public: for (u32 i = 0; i < 12000; i++) { value1 += i; } - Fiber::YieldTo(fiber1, *fiber3); + Fiber::YieldTo(fiber1, fiber3); const u32 id = thread_ids.Get(); assert1 = id == 1; value2 += 5000; - Fiber::YieldTo(fiber1, *thread_fibers[id]); + Fiber::YieldTo(fiber1, thread_fibers[id]); } void DoWork2() { @@ -117,7 +117,7 @@ public: ; value2 = 2000; trap = false; - Fiber::YieldTo(fiber2, *fiber1); + Fiber::YieldTo(fiber2, fiber1); assert3 = false; } @@ -125,19 +125,19 @@ public: const u32 id = thread_ids.Get(); assert2 = id == 0; value1 += 1000; - Fiber::YieldTo(fiber3, *thread_fibers[id]); + Fiber::YieldTo(fiber3, thread_fibers[id]); } void ExecuteThread(u32 id); void CallFiber1() { const u32 id = thread_ids.Get(); - Fiber::YieldTo(thread_fibers[id], *fiber1); + Fiber::YieldTo(thread_fibers[id], fiber1); } void CallFiber2() { const u32 id = thread_ids.Get(); - Fiber::YieldTo(thread_fibers[id], *fiber2); + Fiber::YieldTo(thread_fibers[id], fiber2); } void Exit(); @@ -207,23 +207,23 @@ public: void DoWork1() { value1 += 1; - Fiber::YieldTo(fiber1, *fiber2); + Fiber::YieldTo(fiber1, fiber2); const u32 id = thread_ids.Get(); value3 += 1; - Fiber::YieldTo(fiber1, *thread_fibers[id]); + Fiber::YieldTo(fiber1, thread_fibers[id]); } void DoWork2() { value2 += 1; const u32 id = thread_ids.Get(); - Fiber::YieldTo(fiber2, *thread_fibers[id]); + Fiber::YieldTo(fiber2, thread_fibers[id]); } void ExecuteThread(u32 id); void CallFiber1() { const u32 id = thread_ids.Get(); - Fiber::YieldTo(thread_fibers[id], *fiber1); + Fiber::YieldTo(thread_fibers[id], fiber1); } void Exit(); @@ -283,7 +283,7 @@ public: void Execute() { thread_fiber = Fiber::ThreadToFiber(); - Fiber::YieldTo(thread_fiber, *fiber1); + Fiber::YieldTo(thread_fiber, fiber1); thread_fiber->Exit(); } @@ -291,7 +291,7 @@ public: fiber1->SetRewindPoint([this] { DoWork(); }); if (rewinded) { goal_reached = true; - Fiber::YieldTo(fiber1, *thread_fiber); + Fiber::YieldTo(fiber1, thread_fiber); } rewinded = true; fiber1->Rewind();