debuggerx/eden
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden.git synced 2026-10-09 06:46:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

[dynarmic] Remove redundant constant pool ops

Browse Source 
Signed-off-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie
2026-10-08 12:16:29 +00:00
parent 10bcd2d849
commit 51f2e2bfb9
2 changed files with 20 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/dynarmic/src/dynarmic/backend/x64/constant_pool.cpp
+13 -20
View File
@@ -7,34 +7,27 @@
*/
#include <cstring>
#include "common/assert.h"
#include <cassert>
#include "dynarmic/backend/x64/block_of_code.h"
#include "dynarmic/backend/x64/constant_pool.h"
namespace Dynarmic::Backend::X64 {
ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
: insertion_point(0)
{
code.EnsureMemoryCommitted(align_size + size);
code.int3();
ConstantPool::ConstantPool(BlockOfCode& code, size_t size) noexcept {
auto const align_size = 64; //always align to cacheline
code.EnsureMemoryCommitted(2 * align_size + size);
code.align(align_size);
pool = std::span<ConstantT>(reinterpret_cast<ConstantT*>(code.AllocateFromCodeSpace(size)), size / align_size);
pool = std::span<u128>(static_cast<u128*>(code.AllocateFromCodeSpace(size)), size / sizeof(u128));
}
Xbyak::Address ConstantPool::GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
const auto constant = ConstantT(lower, upper);
auto it = constant_info.find(constant);
if (it == constant_info.end()) {
ASSERT(insertion_point < pool.size());
ConstantT& target_constant = pool[insertion_point];
target_constant = constant;
it = constant_info.insert({constant, &target_constant}).first;
++insertion_point;
}
return frame[code.rip + it->second];
Xbyak::Address ConstantPool::GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lo, u64 hi) noexcept {
// offset grows iff new constant is added
auto const key = std::make_pair(lo, hi);
auto const val = u32(constant_info.size());
auto const [it, _] = constant_info.insert({key, val});
// if it != constant_info.end(): assume(pool[it->second] == c);
pool[it->second] = u128{lo, hi};
return frame[code.rip + std::addressof(pool[it->second])];
}
} // namespace Dynarmic::Backend::X64
src/dynarmic/src/dynarmic/backend/x64/constant_pool.h
+7 -20
View File
@@ -12,6 +12,7 @@
#include <cstddef>
#include <span>
#include <utility>
#include <boost/functional/hash.hpp>
#include "common/common_types.h"
#include "common/container/unordered_map.h"
@@ -21,31 +22,17 @@ namespace Dynarmic::Backend::X64 {
class BlockOfCode;
/// ConstantPool allocates a block of memory from BlockOfCode.
/// @brief ConstantPool allocates a block of memory from BlockOfCode.
/// It places constants into this block of memory, returning the address
/// of the memory location where the constant is placed. If the constant
/// already exists, its memory location is reused.
class ConstantPool final {
public:
ConstantPool(BlockOfCode& code, size_t size);
Xbyak::Address GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);
private:
static constexpr size_t align_size = 16; // bytes
using ConstantT = std::pair<u64, u64>;
static_assert(sizeof(ConstantT) == align_size);
struct ConstantHash {
std::size_t operator()(const ConstantT& constant) const noexcept {
return constant.first ^ std::rotl<u64>(constant.second, 1);
}
};
::Common::unordered_map<ConstantT, void*, ConstantHash> constant_info;
std::span<ConstantT> pool;
std::size_t insertion_point;
ConstantPool(BlockOfCode& code, size_t size) noexcept;
Xbyak::Address GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0) noexcept;
// key = identity hash, value = offset from pool.data()
::Common::unordered_map<std::pair<u64, u64>, u32, boost::hash<std::pair<u64, u64>>> constant_info;
std::span<u128> pool;
};
} // namespace Dynarmic::Backend::X64