video_core: use interval map for page count tracking

This commit is contained in:
Liam 2023-12-12 17:15:52 -05:00
parent 462ba1b360
commit 030e6b3980
7 changed files with 66 additions and 76 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, int delta) { void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {
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 += delta; value += (cache ? 1 : -1);
if (value < 0) { if (value < 0) {
throw std::logic_error{"negative page"}; throw std::logic_error{"negative page"};
} }

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 ? 1 : -1); size * BYTES_PER_PAGE, add_to_rasterizer);
}); });
} }

View file

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

View file

@ -3,8 +3,7 @@
#pragma once #pragma once
#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,28 +20,16 @@ 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, int delta) override; void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) override;
private: private:
class CacheEntry final { using PageIndex = VAddr;
public: using PageReferenceCount = u16;
CacheEntry() = default;
std::atomic_uint16_t& Count(std::size_t page) { using IntervalMap = boost::icl::interval_map<PageIndex, PageReferenceCount>;
return values[page & 3]; using IntervalType = IntervalMap::interval_type;
}
const std::atomic_uint16_t& Count(std::size_t page) const { IntervalMap map;
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, int delta) {} virtual void UpdatePagesCachedCount(VAddr addr, u64 size, bool cache) {}
/// 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, 1); rasterizer.UpdatePagesCachedCount(addr, size, true);
} }
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, -1); rasterizer.UpdatePagesCachedCount(addr, size, false);
} }
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, 1); rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, true);
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, 1); rasterizer.UpdatePagesCachedCount(cpu_addr, size, true);
} }
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, 1); rasterizer.UpdatePagesCachedCount(cpu_addr, size, true);
}); });
} }
@ -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, -1); rasterizer.UpdatePagesCachedCount(image.cpu_addr, image.guest_size_bytes, false);
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, -1); rasterizer.UpdatePagesCachedCount(cpu_addr, size, false);
} }
} }