mirror of
https://git.eden-emu.dev/eden-emu/eden
synced 2026-04-10 05:28:56 +02:00
83a28dc251
for core stuff: just remove unique ptrs that dont need any pointer stability at all (afterall its an allocation within an allocation so yeah) for fibers: Main reasoning behind this is because virtualBuffer<> is stupidly fucking expensive and it also clutters my fstat view ALSO mmap is a syscall, syscalls are bad for performance or whatever ALSO std::vector<> is better suited for handling this kind of "fixed size thing where its like big but not THAT big" (512 KiB isn't going to kill your memory usage for each fiber...) for core.cpp stuff - inlines stuff into std::optional<> as opposed to std::unique_ptr<> (because yknow, we are making the Impl from an unique_ptr, allocating within an allocation is unnecessary) - reorganizes the structures a bit so padding doesnt screw us up (it's not perfect but eh saves a measly 44 bytes) - removes unused/dead code - uses std::vector<> instead of std::deque<> no perf impact expected, maybe some initialisation boost but very minimal impact nonethless lto gets rid of most calls anyways - the heavy issue is with shared_ptr and the cache coherency from the atomics... but i clumped them together because well, they kinda do not suffer from cache coherency - hopefully not a mistake this balloons the size of Impl to about 1.67 MB - which is fine because we throw it in the stack anyways REST OF INTERFACES: most of them ballooned in size as well, but overhead is ok since its an allocation within an alloc, no stack is used (when it comes to storing these i mean) Signed-off-by: lizzie lizzie@eden-emu.dev Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3306 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>
108 lines
3.5 KiB
C++
108 lines
3.5 KiB
C++
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <thread>
|
|
#include <mutex>
|
|
|
|
#include "common/assert.h"
|
|
#include "common/fiber.h"
|
|
#include "common/virtual_buffer.h"
|
|
|
|
#include <boost/context/detail/fcontext.hpp>
|
|
|
|
namespace Common {
|
|
|
|
constexpr size_t DEFAULT_STACK_SIZE = 128 * 4096;
|
|
constexpr u32 CANARY_VALUE = 0xDEADBEEF;
|
|
|
|
struct Fiber::FiberImpl {
|
|
FiberImpl() {}
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|
|
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(), [](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) {
|
|
// 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) {
|
|
impl->guard.unlock();
|
|
impl->released = true;
|
|
}
|
|
}
|
|
|
|
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->previous_fiber == nullptr) {
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
|
|
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
|