mirror of
https://git.eden-emu.dev/eden-emu/eden.git
synced 2026-09-11 06:17:41 +00:00
Exverge
5f142c7926
Reduces the page entries from 32 bytes to 8 and rewrites `VirtualBuffer` to be more efficient in memory usage and specifically for large zero regions. The page table will now only reserve 1GiB instead of 4GiB and of this memory it should only use at most ~8MiB. This PR has the side effect of using Eden on Windows on low memory systems much more plausible since it would previously require ~10GiB of committable memory at front (despite using ~5-6 at most, inadvertently stalling other processes) where as now it should only require around the amount that it'll actually use. Co-authored-by: Lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4219 Reviewed-by: Maufeat <sahyno1996@gmail.com> Reviewed-by: lizzie <lizzie@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
114 lines
3.6 KiB
C++
114 lines
3.6 KiB
C++
// SPDX-FileCopyrightText: Copyright 2026 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 <boost/context/detail/fcontext.hpp>
|
|
|
|
namespace Common {
|
|
|
|
#ifdef __OPENORBIS__
|
|
constexpr size_t DEFAULT_STACK_SIZE = 128 * 4096;
|
|
#else
|
|
constexpr size_t DEFAULT_STACK_SIZE = 512 * 4096;
|
|
#endif
|
|
constexpr u32 CANARY_VALUE = 0xDEADBEEF;
|
|
|
|
struct Fiber::FiberImpl {
|
|
FiberImpl() {}
|
|
|
|
u32 canary_1 = CANARY_VALUE;
|
|
std::array<u8, DEFAULT_STACK_SIZE> stack{};
|
|
std::array<u8, DEFAULT_STACK_SIZE> rewind_stack{};
|
|
u32 canary_2 = 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_1 == CANARY_VALUE);
|
|
ASSERT(fiber->impl->canary_2 == 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
|