Merge pull request #12391 from yuzu-emu/revert-12344-its-free-real-estate

Revert "video_core: use interval map for page count tracking"
This commit is contained in:
Fernando S 2023-12-19 16:14:09 +01:00 committed by GitHub
commit 97ad3e7530
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 76 additions and 70 deletions

View file

@ -23,13 +23,13 @@ constexpr VAddr c = 16 * HIGH_PAGE_SIZE;
class RasterizerInterface { class RasterizerInterface {
public: public:
void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) { void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
const u64 page_start{addr >> Core::Memory::YUZU_PAGEBITS}; const u64 page_start{addr >> Core::Memory::YUZU_PAGEBITS};
const u64 page_end{(addr + size + Core::Memory::YUZU_PAGESIZE - 1) >> const u64 page_end{(addr + size + Core::Memory::YUZU_PAGESIZE - 1) >>
Core::Memory::YUZU_PAGEBITS}; Core::Memory::YUZU_PAGEBITS};
for (u64 page = page_start; page < page_end; ++page) { for (u64 page = page_start; page < page_end; ++page) {
int& value = page_table[page]; int& value = page_table[page];
value += (cache ? 1 : -1); value += delta;
if (value < 0) { if (value < 0) {
throw std::logic_error{"negative page"}; throw std::logic_error{"negative page"};
} }
@ -546,4 +546,4 @@ TEST_CASE("MemoryTracker: Cached write downloads") {
REQUIRE(!memory_track->IsRegionGpuModified(c + PAGE, PAGE)); REQUIRE(!memory_track->IsRegionGpuModified(c + PAGE, PAGE));
memory_track->MarkRegionAsCpuModified(c, WORD); memory_track->MarkRegionAsCpuModified(c, WORD);
REQUIRE(rasterizer.Count() == 0); REQUIRE(rasterizer.Count() == 0);
} }

View file

@ -473,7 +473,7 @@ private:
VAddr addr = cpu_addr + word_index * BYTES_PER_WORD; VAddr addr = cpu_addr + word_index * BYTES_PER_WORD;
IteratePages(changed_bits, [&](size_t offset, size_t size) { IteratePages(changed_bits, [&](size_t offset, size_t size) {
rasterizer->UpdatePagesCachedCount(addr + offset * BYTES_PER_PAGE, rasterizer->UpdatePagesCachedCount(addr + offset * BYTES_PER_PAGE,
size * BYTES_PER_PAGE, add_to_rasterizer); size * BYTES_PER_PAGE, add_to_rasterizer ? 1 : -1);
}); });
} }

View file

@ -3,7 +3,6 @@
#include <atomic> #include <atomic>
#include "common/alignment.h"
#include "common/assert.h" #include "common/assert.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "common/div_ceil.h" #include "common/div_ceil.h"
@ -12,65 +11,61 @@
namespace VideoCore { namespace VideoCore {
static constexpr u16 IdentityValue = 1;
using namespace Core::Memory; using namespace Core::Memory;
RasterizerAccelerated::RasterizerAccelerated(Memory& cpu_memory_) : map{}, cpu_memory{cpu_memory_} { RasterizerAccelerated::RasterizerAccelerated(Memory& cpu_memory_)
// We are tracking CPU memory, which cannot map more than 39 bits. : cached_pages(std::make_unique<CachedPages>()), cpu_memory{cpu_memory_} {}
const VAddr start_address = 0;
const VAddr end_address = (1ULL << 39);
const IntervalType address_space_interval(start_address, end_address);
const auto value = std::make_pair(address_space_interval, IdentityValue);
map.add(value);
}
RasterizerAccelerated::~RasterizerAccelerated() = default; RasterizerAccelerated::~RasterizerAccelerated() = default;
void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) { void RasterizerAccelerated::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
std::scoped_lock lk{map_lock}; u64 uncache_begin = 0;
u64 cache_begin = 0;
u64 uncache_bytes = 0;
u64 cache_bytes = 0;
// Align sizes. std::atomic_thread_fence(std::memory_order_acquire);
addr = Common::AlignDown(addr, YUZU_PAGESIZE); const u64 page_end = Common::DivCeil(addr + size, YUZU_PAGESIZE);
size = Common::AlignUp(size, YUZU_PAGESIZE); for (u64 page = addr >> YUZU_PAGEBITS; page != page_end; ++page) {
std::atomic_uint16_t& count = cached_pages->at(page >> 2).Count(page);
// Declare the overall interval we are going to operate on. if (delta > 0) {
const VAddr start_address = addr; ASSERT_MSG(count.load(std::memory_order::relaxed) < UINT16_MAX, "Count may overflow!");
const VAddr end_address = addr + size; } else if (delta < 0) {
const IntervalType modification_range(start_address, end_address); ASSERT_MSG(count.load(std::memory_order::relaxed) > 0, "Count may underflow!");
} else {
ASSERT_MSG(false, "Delta must be non-zero!");
}
// Find the boundaries of where to iterate. // Adds or subtracts 1, as count is a unsigned 8-bit value
const auto lower = map.lower_bound(modification_range); count.fetch_add(static_cast<u16>(delta), std::memory_order_release);
const auto upper = map.upper_bound(modification_range);
// Iterate over the contained intervals. // Assume delta is either -1 or 1
for (auto it = lower; it != upper; it++) { if (count.load(std::memory_order::relaxed) == 0) {
// Intersect interval range with modification range. if (uncache_bytes == 0) {
const auto current_range = modification_range & it->first; uncache_begin = page;
}
// Calculate the address and size to operate over. uncache_bytes += YUZU_PAGESIZE;
const auto current_addr = current_range.lower(); } else if (uncache_bytes > 0) {
const auto current_size = current_range.upper() - current_addr; cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes,
false);
// Get the current value of the range. uncache_bytes = 0;
const auto value = it->second; }
if (count.load(std::memory_order::relaxed) == 1 && delta > 0) {
if (cache && value == IdentityValue) { if (cache_bytes == 0) {
// If we are going to cache, and the value is not yet referenced, then cache this range. cache_begin = page;
cpu_memory.RasterizerMarkRegionCached(current_addr, current_size, true); }
} else if (!cache && value == IdentityValue + 1) { cache_bytes += YUZU_PAGESIZE;
// If we are going to uncache, and this is the last reference, then uncache this range. } else if (cache_bytes > 0) {
cpu_memory.RasterizerMarkRegionCached(current_addr, current_size, false); cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
cache_bytes = 0;
} }
} }
if (uncache_bytes > 0) {
// Update the set. cpu_memory.RasterizerMarkRegionCached(uncache_begin << YUZU_PAGEBITS, uncache_bytes, false);
const auto value = std::make_pair(modification_range, IdentityValue); }
if (cache) { if (cache_bytes > 0) {
map.add(value); cpu_memory.RasterizerMarkRegionCached(cache_begin << YUZU_PAGEBITS, cache_bytes, true);
} else {
map.subtract(value);
} }
} }

View file

@ -3,8 +3,8 @@
#pragma once #pragma once
#include <mutex> #include <array>
#include <boost/icl/interval_map.hpp> #include <atomic>
#include "common/common_types.h" #include "common/common_types.h"
#include "video_core/rasterizer_interface.h" #include "video_core/rasterizer_interface.h"
@ -21,17 +21,28 @@ public:
explicit RasterizerAccelerated(Core::Memory::Memory& cpu_memory_); explicit RasterizerAccelerated(Core::Memory::Memory& cpu_memory_);
~RasterizerAccelerated() override; ~RasterizerAccelerated() override;
void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) override; void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) override;
private: private:
using PageIndex = VAddr; class CacheEntry final {
using PageReferenceCount = u16; public:
CacheEntry() = default;
using IntervalMap = boost::icl::interval_map<PageIndex, PageReferenceCount>; std::atomic_uint16_t& Count(std::size_t page) {
using IntervalType = IntervalMap::interval_type; return values[page & 3];
}
IntervalMap map; const std::atomic_uint16_t& Count(std::size_t page) const {
std::mutex map_lock; return values[page & 3];
}
private:
std::array<std::atomic_uint16_t, 4> values{};
};
static_assert(sizeof(CacheEntry) == 8, "CacheEntry should be 8 bytes!");
using CachedPages = std::array<CacheEntry, 0x2000000>;
std::unique_ptr<CachedPages> cached_pages;
Core::Memory::Memory& cpu_memory; Core::Memory::Memory& cpu_memory;
}; };

View file

@ -162,7 +162,7 @@ public:
} }
/// Increase/decrease the number of object in pages touching the specified region /// Increase/decrease the number of object in pages touching the specified region
virtual void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {} virtual void UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {}
/// Initialize disk cached resources for the game being emulated /// Initialize disk cached resources for the game being emulated
virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading, virtual void LoadDiskResources(u64 title_id, std::stop_token stop_loading,

View file

@ -132,7 +132,7 @@ void ShaderCache::Register(std::unique_ptr<ShaderInfo> data, VAddr addr, size_t
storage.push_back(std::move(data)); storage.push_back(std::move(data));
rasterizer.UpdatePagesCachedCount(addr, size, true); rasterizer.UpdatePagesCachedCount(addr, size, 1);
} }
void ShaderCache::InvalidatePagesInRegion(VAddr addr, size_t size) { void ShaderCache::InvalidatePagesInRegion(VAddr addr, size_t size) {
@ -209,7 +209,7 @@ void ShaderCache::UnmarkMemory(Entry* entry) {
const VAddr addr = entry->addr_start; const VAddr addr = entry->addr_start;
const size_t size = entry->addr_end - addr; const size_t size = entry->addr_end - addr;
rasterizer.UpdatePagesCachedCount(addr, size, false); rasterizer.UpdatePagesCachedCount(addr, size, -1);
} }
void ShaderCache::RemoveShadersFromStorage(std::span<ShaderInfo*> removed_shaders) { void ShaderCache::RemoveShadersFromStorage(std::span<ShaderInfo*> removed_shaders) {

View file

@ -2080,7 +2080,7 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
ASSERT(False(image.flags & ImageFlagBits::Tracked)); ASSERT(False(image.flags & ImageFlagBits::Tracked));
image.flags |= ImageFlagBits::Tracked; image.flags |= ImageFlagBits::Tracked;
if (False(image.flags & ImageFlagBits::Sparse)) { if (False(image.flags & ImageFlagBits::Sparse)) {
rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, true); rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, 1);
return; return;
} }
if (True(image.flags & ImageFlagBits::Registered)) { if (True(image.flags & ImageFlagBits::Registered)) {
@ -2091,13 +2091,13 @@ void TextureCache<P>::TrackImage(ImageBase& image, ImageId image_id) {
const auto& map = slot_map_views[map_view_id]; const auto& map = slot_map_views[map_view_id];
const VAddr cpu_addr = map.cpu_addr; const VAddr cpu_addr = map.cpu_addr;
const std::size_t size = map.size; const std::size_t size = map.size;
rasterizer.UpdatePagesCachedCount(cpu_addr, size, true); rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
} }
return; return;
} }
ForEachSparseSegment(image, ForEachSparseSegment(image,
[this]([[maybe_unused]] GPUVAddr gpu_addr, VAddr cpu_addr, size_t size) { [this]([[maybe_unused]] GPUVAddr gpu_addr, VAddr cpu_addr, size_t size) {
rasterizer.UpdatePagesCachedCount(cpu_addr, size, true); rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
}); });
} }
@ -2106,7 +2106,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
ASSERT(True(image.flags & ImageFlagBits::Tracked)); ASSERT(True(image.flags & ImageFlagBits::Tracked));
image.flags &= ~ImageFlagBits::Tracked; image.flags &= ~ImageFlagBits::Tracked;
if (False(image.flags & ImageFlagBits::Sparse)) { if (False(image.flags & ImageFlagBits::Sparse)) {
rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, false); rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, -1);
return; return;
} }
ASSERT(True(image.flags & ImageFlagBits::Registered)); ASSERT(True(image.flags & ImageFlagBits::Registered));
@ -2117,7 +2117,7 @@ void TextureCache<P>::UntrackImage(ImageBase& image, ImageId image_id) {
const auto& map = slot_map_views[map_view_id]; const auto& map = slot_map_views[map_view_id];
const VAddr cpu_addr = map.cpu_addr; const VAddr cpu_addr = map.cpu_addr;
const std::size_t size = map.size; const std::size_t size = map.size;
rasterizer.UpdatePagesCachedCount(cpu_addr, size, false); rasterizer.UpdatePagesCachedCount(cpu_addr, size, -1);
} }
} }