RPCSX/rpcsx
1
0
Fork 0
mirror of https://github.com/RPCSX/rpcsx.git synced 2026-03-01 02:54:24 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

rx/MemoryTable: simplify map/unmap api

Browse source
This commit is contained in:
DH 2025-10-12 00:04:30 +03:00
parent 7099a71b06
commit 0fb7aeb9b4
9 changed files with 58 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
kernel/orbis/include/orbis/KernelAllocator.hpp
View file

@ -59,7 +59,9 @@ T *knew(Args &&...args) {
struct DynamicObject final : T {
using T::T;
void operator delete(void *pointer) { kfree(pointer, sizeof(T)); }
void operator delete(void *pointer) {
kfree(pointer, sizeof(DynamicObject));
}
};
auto loc = static_cast<DynamicObject *>(

31
rpcsx/gpu/Cache.cpp
View file

@ -167,8 +167,8 @@ void Cache::ShaderResources::loadResources(
rx::die("failed to evaluate pointer");
}
bufferMemoryTable.map(*pointerBase + *pointerOffset,
*pointerBase + *pointerOffset + pointer.size,
bufferMemoryTable.map(rx::AddressRange::fromBeginSize(
*pointerBase + *pointerOffset, pointer.size),
Access::Read);
resourceSlotToAddress.emplace_back(slotOffset + pointer.resourceSlot,
*pointerBase + *pointerOffset);
@ -200,8 +200,9 @@ void Cache::ShaderResources::loadResources(
it.beginAddress() == buffer.address() && it.size() == buffer.size()) {
it.get() |= bufferRes.access;
} else {
bufferMemoryTable.map(buffer.address(), buffer.address() + buffer.size(),
bufferRes.access);
bufferMemoryTable.map(
rx::AddressRange::fromBeginSize(buffer.address(), buffer.size()),
bufferRes.access);
}
resourceSlotToAddress.emplace_back(slotOffset + bufferRes.resourceSlot,
buffer.address());
@ -262,7 +263,8 @@ void Cache::ShaderResources::loadResources(
it.get().second |= imageBuffer.access;
} else {
imageMemoryTable.map(
tbuffer.address(), tbuffer.address() + info.totalTiledSize,
rx::AddressRange::fromBeginSize(tbuffer.address(),
info.totalTiledSize),
{ImageBufferKey::createFrom(tbuffer), imageBuffer.access});
}
resourceSlotToAddress.emplace_back(slotOffset + imageBuffer.resourceSlot,
@ -1489,8 +1491,7 @@ Cache::Buffer Cache::Tag::getBuffer(rx::AddressRange range, Access access) {
mParent->flushBuffers(range);
it = table.map(range.beginAddress(), range.endAddress(), nullptr, false,
true);
it = table.map(range, nullptr, false, true);
}
if (it.get() == nullptr) {
@ -1837,8 +1838,7 @@ Cache::ImageBuffer Cache::Tag::getImageBuffer(const ImageBufferKey &key,
flushed.clear();
}
auto it =
table.map(range.beginAddress(), range.endAddress(), nullptr, false, true);
auto it = table.map(range, nullptr, false, true);
if (it.get() == nullptr) {
auto cached = std::make_shared<CachedImageBuffer>();
@ -1945,8 +1945,7 @@ Cache::Image Cache::Tag::getImage(const ImageKey &key, Access access) {
flushed.clear();
}
auto it = table.map(storeRange.beginAddress(), storeRange.endAddress(),
nullptr, false, true);
auto it = table.map(storeRange, nullptr, false, true);
if (it.get() == nullptr) {
VkImageUsageFlags usage =
@ -2787,15 +2786,13 @@ void Cache::flush(Tag &tag, rx::AddressRange range) {
void Cache::trackUpdate(EntryType type, rx::AddressRange range,
std::shared_ptr<Entry> entry, TagId tagId,
bool watchChanges) {
if (auto it = mSyncTable.map(range.beginAddress(), range.endAddress(), {},
false, true);
it.get() < tagId) {
if (auto it = mSyncTable.map(range, {}, false, true); it.get() < tagId) {
it.get() = tagId;
}
entry->tagId = tagId;
auto &table = getTable(type);
table.map(range.beginAddress(), range.endAddress(), std::move(entry));
table.map(range, std::move(entry));
if (watchChanges) {
mDevice->watchWrites(mVmId, range.beginAddress(), range.size());
@ -2803,9 +2800,7 @@ void Cache::trackUpdate(EntryType type, rx::AddressRange range,
}
void Cache::trackWrite(rx::AddressRange range, TagId tagId, bool lockMemory) {
if (auto it = mSyncTable.map(range.beginAddress(), range.endAddress(), {},
false, true);
it.get() < tagId) {
if (auto it = mSyncTable.map(range, {}, false, true); it.get() < tagId) {
it.get() = tagId;
}

4
rpcsx/gpu/Device.cpp
View file

@ -641,7 +641,7 @@ void Device::protectMemory(std::uint32_t pid, std::uint64_t address,
auto vmSlot = vmSlotIt.get();
process.vmTable.map(address, address + size,
process.vmTable.map(rx::AddressRange::fromBeginSize(address, size),
VmMapSlot{
.memoryType = vmSlot.memoryType,
.prot = static_cast<int>(prot),
@ -1004,7 +1004,7 @@ void Device::mapMemory(std::uint32_t pid, std::uint64_t address,
int prot, std::int64_t offset) {
auto &process = processInfo[pid];
process.vmTable.map(address, address + size,
process.vmTable.map(rx::AddressRange::fromBeginSize(address, size),
VmMapSlot{
.memoryType = memoryType >= 0 ? dmemIndex : -1,
.prot = prot,

3
rpcsx/gpu/lib/gcn-shader/src/gcn.cpp
View file

@ -1832,7 +1832,8 @@ gcn::deserialize(gcn::Context &context, const gcn::Environment &environment,
std::function<std::uint32_t(std::uint64_t)> readMemory) {
readMemory = [&context,
readMemory = std::move(readMemory)](std::uint64_t address) {
context.memoryMap.map(address, address + sizeof(std::uint32_t));
context.memoryMap.map(
rx::AddressRange::fromBeginSize(address, sizeof(std::uint32_t)));
return readMemory(address);
};

8
rpcsx/gpu/lib/vk/include/vk.hpp
View file

@ -322,7 +322,7 @@ public:
auto properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
mMemory = DeviceMemory::CreateExternalHostMemory(data, size, properties);
table.map(0, size);
table.map(rx::AddressRange::fromBeginSize(0, size));
// debugName = "direct";
}
@ -337,7 +337,7 @@ public:
vkMapMemory(context->device, memory.getHandle(), 0, size, 0, &data));
mMemory = std::move(memory);
table.map(0, size);
table.map(rx::AddressRange::fromBeginSize(0, size));
mData = reinterpret_cast<char *>(data);
// debugName = "host";
}
@ -347,7 +347,7 @@ public:
auto properties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
mMemory = DeviceMemory::Allocate(size, ~0, properties);
table.map(0, size);
table.map(rx::AddressRange::fromBeginSize(0, size));
// debugName = "local";
}
@ -397,7 +397,7 @@ public:
void deallocate(DeviceMemoryRef memory) {
std::lock_guard lock(mMtx);
table.map(memory.offset, memory.offset + memory.size);
table.map(rx::AddressRange::fromBeginSize(memory.offset, memory.size));
}
void dump() {

2
rpcsx/iodev/blockpool.cpp
View file

@ -37,7 +37,7 @@ static orbis::ErrorCode blockpool_ioctl(orbis::File *file,
ORBIS_RET_ON_ERROR(
dmem->allocate(&start, args->searchEnd, args->len, 1, args->flags));
blockPool->pool.map(start, start + args->len);
blockPool->pool.map(rx::AddressRange::fromBeginSize(start, args->len));
return {};
}
}

9
rpcsx/iodev/dmem.cpp
View file

@ -144,8 +144,9 @@ static orbis::ErrorCode dmem_ioctl(orbis::File *file, std::uint64_t request,
ORBIS_LOG_WARNING("dmem releaseDirectMemory", device->index, args->address,
args->size);
device->allocations.map(args->address, args->address + args->size,
{.memoryType = -1u});
device->allocations.map(
rx::AddressRange::fromBeginSize(args->address, args->size),
{.memoryType = -1u});
return {};
}
@ -303,7 +304,7 @@ orbis::ErrorCode DmemDevice::allocate(std::uint64_t *start,
}
}
allocations.map(offset, offset + len,
allocations.map(rx::AddressRange::fromBeginSize(offset, len),
{
.memoryType = memoryType,
});
@ -319,7 +320,7 @@ orbis::ErrorCode DmemDevice::allocate(std::uint64_t *start,
}
orbis::ErrorCode DmemDevice::release(std::uint64_t start, std::uint64_t size) {
allocations.unmap(start, start + size);
allocations.unmap(rx::AddressRange::fromBeginSize(start, size));
return {};
}

10
rpcsx/vm.cpp
View file

@ -776,8 +776,8 @@ constexpr auto kMainDirectMemorySize =
kPhysicalMemorySize - kFlexibleMemorySize;
void *vm::map(void *addr, std::uint64_t len, std::int32_t prot,
std::int32_t flags, std::int32_t internalFlags, orbis::IoDevice *device,
std::uint64_t offset) {
std::int32_t flags, std::int32_t internalFlags,
orbis::IoDevice *device, std::uint64_t offset) {
std::println(stderr, "vm::map(addr = {}, len = {}, prot = {}, flags = {})",
addr, len, mapProtToString(prot), mapFlagsToString(flags));
@ -966,7 +966,7 @@ void *vm::map(void *addr, std::uint64_t len, std::int32_t prot,
info.flags = flags;
info.offset = offset;
gMapInfo.map(address, address + len, info);
gMapInfo.map(rx::AddressRange::fromBeginSize(address, len), info);
}
if (auto thr = orbis::g_currentThread) {
@ -1034,7 +1034,7 @@ bool vm::unmap(void *addr, std::uint64_t size) {
std::println(stderr, "ignoring unmapping {:x}-{:x}", address,
address + size);
}
gMapInfo.unmap(address, address + size);
gMapInfo.unmap(rx::AddressRange::fromBeginSize(address, size));
return rx::mem::unmap(addr, size);
}
@ -1218,5 +1218,5 @@ void vm::setName(std::uint64_t start, std::uint64_t size, const char *name) {
std::strncpy(info.name, name, sizeof(info.name));
gMapInfo.map(start, size, info);
gMapInfo.map(rx::AddressRange::fromBeginSize(start, size), info);
}

47
rx/include/rx/MemoryTable.hpp
View file

@ -66,7 +66,7 @@ public:
void clear() { mAreas.clear(); }
AreaInfo queryArea(std::uint64_t address) const {
[[nodiscard]] AreaInfo queryArea(std::uint64_t address) const {
auto it = mAreas.lower_bound(address);
assert(it != mAreas.end());
std::uint64_t endAddress = 0;
@ -84,9 +84,10 @@ public:
return {startAddress, endAddress};
}
void map(std::uint64_t beginAddress, std::uint64_t endAddress) {
auto [beginIt, beginInserted] = mAreas.emplace(beginAddress, Kind::O);
auto [endIt, endInserted] = mAreas.emplace(endAddress, Kind::X);
void map(rx::AddressRange range) {
auto [beginIt, beginInserted] =
mAreas.emplace(range.beginAddress(), Kind::O);
auto [endIt, endInserted] = mAreas.emplace(range.endAddress(), Kind::X);
if (!beginInserted) {
if (beginIt->second == Kind::X) {
@ -313,9 +314,8 @@ public:
};
template <typename T> class Payload<T *> {
static constexpr std::uintptr_t
kCloseOpenBit = alignof(T) > 1 ? 1
: (1ull << (sizeof(std::uintptr_t) * 8 - 1));
static constexpr std::uintptr_t kCloseOpenBit =
alignof(T) > 1 ? 1 : (1ull << (sizeof(std::uintptr_t) * 8 - 1));
static constexpr std::uintptr_t kClose = 0;
std::uintptr_t value = kClose;
@ -368,9 +368,8 @@ public:
};
template <typename T> class Payload<Ref<T>> {
static constexpr std::uintptr_t
kCloseOpenBit = alignof(T) > 1 ? 1
: (1ull << (sizeof(std::uintptr_t) * 8 - 1));
static constexpr std::uintptr_t kCloseOpenBit =
alignof(T) > 1 ? 1 : (1ull << (sizeof(std::uintptr_t) * 8 - 1));
static constexpr std::uintptr_t kClose = 0;
std::uintptr_t value = kClose;
@ -465,14 +464,14 @@ class MemoryTableWithPayload {
public:
class AreaInfo : public rx::AddressRange {
PayloadT &payload;
Payload<PayloadT> &payload;
public:
AreaInfo(PayloadT &payload, rx::AddressRange range)
AreaInfo(Payload<PayloadT> &payload, rx::AddressRange range)
: payload(payload), AddressRange(range) {}
PayloadT *operator->() { return &payload; }
PayloadT &get() { return payload; }
decltype(auto) operator->() { return &payload.get(); }
decltype(auto) get() { return payload.get(); }
};
class iterator {
@ -484,7 +483,7 @@ public:
iterator() = default;
iterator(map_iterator it) : it(it) {}
AreaInfo operator*() const { return {it->second.get(), range()}; }
AreaInfo operator*() const { return {it->second, range()}; }
rx::AddressRange range() const {
return rx::AddressRange::fromBeginEnd(beginAddress(), endAddress());
@ -494,8 +493,8 @@ public:
std::uint64_t endAddress() const { return std::next(it)->first; }
std::uint64_t size() const { return endAddress() - beginAddress(); }
PayloadT &get() const { return it->second.get(); }
PayloadT *operator->() const { return &it->second.get(); }
decltype(auto) get() const { return it->second.get(); }
decltype(auto) operator->() const { return &it->second.get(); }
iterator &operator++() {
++it;
@ -570,13 +569,13 @@ public:
return endAddress < address ? mAreas.end() : it;
}
iterator map(std::uint64_t beginAddress, std::uint64_t endAddress,
PayloadT payload, bool merge = true, bool noOverride = false) {
assert(beginAddress < endAddress);
iterator map(rx::AddressRange range, PayloadT payload, bool merge = true,
bool noOverride = false) {
assert(range.beginAddress() < range.endAddress());
auto [beginIt, beginInserted] =
mAreas.emplace(beginAddress, payload_type::createOpen(payload));
mAreas.emplace(range.beginAddress(), payload_type::createOpen(payload));
auto [endIt, endInserted] =
mAreas.emplace(endAddress, payload_type::createClose());
mAreas.emplace(range.endAddress(), payload_type::createClose());
bool seenOpen = false;
bool endCollision = false;
@ -685,9 +684,9 @@ public:
}
}
void unmap(std::uint64_t beginAddress, std::uint64_t endAddress) {
void unmap(rx::AddressRange range) {
// FIXME: can be optimized
unmap(map(beginAddress, endAddress, PayloadT{}, false));
unmap(map(range, PayloadT{}, false));
}
};
} // namespace rx