mirror of
https://github.com/FEX-Emu/FEX.git
synced 2026-10-07 04:05:14 +02:00
Ryan Houdek
6734c9ed3e
This removes the fairly long lived lock that the buffer allocator held while doing significantly more work than intended while holding that lock. As the first step towards moving over to the atomic bitmap allocator, change this to be atomic to closer match what the new allocator is doing. Since we are just doing linear allocations, this is an easy convert and should give a good stutter improvement.
118 lines
3.8 KiB
C++
118 lines
3.8 KiB
C++
// SPDX-License-Identifier: MIT
|
|
/*
|
|
$info$
|
|
category: code buffer ~ Thread shared code buffer management
|
|
tags: backend|shared
|
|
$end_info$
|
|
*/
|
|
#pragma once
|
|
|
|
#include <FEXCore/fextl/memory.h>
|
|
#include <FEXCore/Utils/MathUtils.h>
|
|
#include <FEXCore/Utils/SignalScopeGuards.h>
|
|
#include <FEXCore/Utils/TypeDefines.h>
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
|
|
namespace FEXCore {
|
|
struct GuestToHostMap;
|
|
}
|
|
|
|
namespace FEXCore::CPU {
|
|
struct CodeBuffer {
|
|
uint8_t* Ptr;
|
|
size_t AllocatedSize; // including guard page; see UsableSize()
|
|
|
|
fextl::unique_ptr<GuestToHostMap> LookupCache;
|
|
|
|
CodeBuffer(size_t Size);
|
|
CodeBuffer(const CodeBuffer&) = delete;
|
|
CodeBuffer& operator=(const CodeBuffer&) = delete;
|
|
CodeBuffer(CodeBuffer&& oth) = delete;
|
|
CodeBuffer& operator=(CodeBuffer&&) = delete;
|
|
|
|
~CodeBuffer();
|
|
|
|
/// Returns the number of bytes available for storing code
|
|
size_t UsableSize() const {
|
|
return AllocatedSize - FEXCore::Utils::FEX_PAGE_SIZE;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A manager that coordinates access to the CodeBuffer used for compiling new code across threads.
|
|
*
|
|
* The CodeBuffer is managed as a partially persistent data structure:
|
|
* - Exactly one CodeBuffer is now designated as "active", which means data can be appended to it
|
|
* - Lossy modifications to the active CodeBuffer will not invalidate any data in use by other threads (which is what enables save CodeBuffer sharing across threads)
|
|
* - Instead, such lossy modifications trigger a new "version" of the data in the modifying thread. Old versions of the CodeBuffer persist as read-only data for use by the other threads.
|
|
* - The other threads can update their version of the CodeBuffer. This will decrease the reference count and eventually trigger deallocation of the old version
|
|
*/
|
|
class SharedCodeBufferManager {
|
|
public:
|
|
// Get the CodeBuffer that was most recently allocated.
|
|
// This is the only CodeBuffer that data may be written to.
|
|
fextl::shared_ptr<CodeBuffer> GetLatest();
|
|
|
|
// Allocate a new CodeBuffer with geometric growth up to an internal maximum.
|
|
// Subsequent calls to GetLatest will point to the returned buffer.
|
|
fextl::shared_ptr<CodeBuffer> StartLargerCodeBuffer();
|
|
|
|
// Allocate a new CodeBuffer with maximum internal size.
|
|
// Subsequent calls to GetLatest will point to the returned buffer.
|
|
fextl::shared_ptr<CodeBuffer> StartMaximalCodeBuffer();
|
|
|
|
// Write offset into the latest CodeBuffer
|
|
uint8_t* CodeBufferBase {};
|
|
uint8_t* CodeBufferEnd {};
|
|
std::atomic<uint8_t*> CodeBufferOffset {};
|
|
|
|
// Atomically allocate a fixed size buffer out of the current allocated codebuffer.
|
|
// Lockless because it's just a linear allocator.
|
|
struct CodeBufferAllocation {
|
|
const uint8_t* BufferBase;
|
|
uint8_t* BufferAllocationOffset;
|
|
};
|
|
|
|
CodeBufferAllocation AtomicAllocateBuffer(size_t Size) {
|
|
Size = FEXCore::AlignUp(Size, 16);
|
|
LOGMAN_THROW_A_FMT(reinterpret_cast<uintptr_t>(CodeBufferOffset.load()) % 16 == 0, "Buffer needs to always be 16B aligned!");
|
|
|
|
auto ExpectedOffset = CodeBufferOffset.load(std::memory_order_relaxed);
|
|
auto DesiredOffset = ExpectedOffset + Size;
|
|
|
|
if (DesiredOffset > CodeBufferEnd) {
|
|
// Couldn't fit.
|
|
return {};
|
|
}
|
|
|
|
while (!CodeBufferOffset.compare_exchange_strong(ExpectedOffset, DesiredOffset)) {
|
|
DesiredOffset = ExpectedOffset + Size;
|
|
|
|
if (DesiredOffset > CodeBufferEnd) {
|
|
// Couldn't fit.
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// Managed to fit.
|
|
return {
|
|
.BufferBase = CodeBufferBase,
|
|
.BufferAllocationOffset = ExpectedOffset,
|
|
};
|
|
}
|
|
|
|
size_t GetAllocatedSize() const {
|
|
return CodeBufferOffset - CodeBufferBase;
|
|
}
|
|
|
|
virtual void OnCodeBufferAllocated(const std::shared_ptr<CodeBuffer>&) {};
|
|
|
|
private:
|
|
fextl::shared_ptr<CodeBuffer> Latest;
|
|
|
|
fextl::shared_ptr<CodeBuffer> AllocateNew(size_t Size);
|
|
};
|
|
} // namespace FEXCore::CPU
|