mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-07-23 18:45:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Page manager bitarray

Browse Source
This commit is contained in:
Lander Gallastegi 2025-06-10 00:25:37 +02:00
parent 2fc62b5b5f
commit 6b60a8515f
3 changed files with 105 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/bit_array.h
View File

@ -152,6 +152,10 @@ public:
data.fill(0);
}
inline constexpr void Fill() {
data.fill(~0ULL);
}
inline constexpr bool None() const {
u64 result = 0;
for (const auto& word : data) {

7
src/video_core/buffer_cache/region_definitions.h
View File

@ -11,12 +11,11 @@ namespace VideoCore {
constexpr u64 PAGES_PER_WORD = 64;
constexpr u64 BYTES_PER_PAGE = 4_KB;
constexpr u64 BYTES_PER_WORD = PAGES_PER_WORD * BYTES_PER_PAGE;
constexpr u64 HIGHER_PAGE_BITS = 22;
constexpr u64 HIGHER_PAGE_SIZE = 1ULL << HIGHER_PAGE_BITS;
constexpr u64 HIGHER_PAGE_MASK = HIGHER_PAGE_SIZE - 1ULL;
constexpr u64 NUM_REGION_WORDS = HIGHER_PAGE_SIZE / BYTES_PER_WORD;
constexpr u64 NUM_REGION_PAGES = HIGHER_PAGE_SIZE / BYTES_PER_PAGE;
enum class Type {
CPU,
@ -24,8 +23,6 @@ enum class Type {
Untracked,
};
using WordsArray = std::array<u64, NUM_REGION_WORDS>;
// TODO: use this insteed of WordsArray once it is ready
using RegionBits = Common::BitArray<NUM_REGION_WORDS * PAGES_PER_WORD>;
using RegionBits = Common::BitArray<NUM_REGION_PAGES>;
} // namespace VideoCore

243
src/video_core/buffer_cache/region_manager.h
View File

@ -4,8 +4,8 @@
#pragma once
#include <mutex>
#include <span>
#include <utility>
#include "common/div_ceil.h"
#ifdef __linux__
#include "common/adaptive_mutex.h"
@ -14,8 +14,8 @@
#endif
#include "common/debug.h"
#include "common/types.h"
#include "video_core/page_manager.h"
#include "video_core/buffer_cache/region_definitions.h"
#include "video_core/page_manager.h"
namespace VideoCore {
@ -27,9 +27,9 @@ class RegionManager {
public:
explicit RegionManager(PageManager* tracker_, VAddr cpu_addr_)
: tracker{tracker_}, cpu_addr{cpu_addr_} {
cpu.fill(~u64{0});
gpu.fill(0);
untracked.fill(~u64{0});
cpu.Fill();
gpu.Clear();
untracked.Fill();
}
explicit RegionManager() = default;
@ -41,67 +41,35 @@ public:
return cpu_addr;
}
static constexpr u64 ExtractBits(u64 word, size_t page_start, size_t page_end) {
constexpr size_t number_bits = sizeof(u64) * 8;
const size_t limit_page_end = number_bits - std::min(page_end, number_bits);
u64 bits = (word >> page_start) << page_start;
bits = (bits << limit_page_end) >> limit_page_end;
return bits;
static constexpr size_t SanitizeAddress(size_t address) {
return static_cast<size_t>(std::max<s64>(static_cast<s64>(address), 0LL));
}
static constexpr std::pair<size_t, size_t> GetWordPage(VAddr address) {
const size_t converted_address = static_cast<size_t>(address);
const size_t word_number = converted_address / BYTES_PER_WORD;
const size_t amount_pages = converted_address % BYTES_PER_WORD;
return std::make_pair(word_number, amount_pages / BYTES_PER_PAGE);
}
template <typename Func>
void IterateWords(size_t offset, size_t size, Func&& func) const {
RENDERER_TRACE;
using FuncReturn = std::invoke_result_t<Func, std::size_t, u64>;
static constexpr bool BOOL_BREAK = std::is_same_v<FuncReturn, bool>;
const size_t start = static_cast<size_t>(std::max<s64>(static_cast<s64>(offset), 0LL));
const size_t end = static_cast<size_t>(std::max<s64>(static_cast<s64>(offset + size), 0LL));
if (start >= HIGHER_PAGE_SIZE || end <= start) {
return;
}
auto [start_word, start_page] = GetWordPage(start);
auto [end_word, end_page] = GetWordPage(end + BYTES_PER_PAGE - 1ULL);
constexpr size_t num_words = NUM_REGION_WORDS;
start_word = std::min(start_word, num_words);
end_word = std::min(end_word, num_words);
const size_t diff = end_word - start_word;
end_word += (end_page + PAGES_PER_WORD - 1ULL) / PAGES_PER_WORD;
end_word = std::min(end_word, num_words);
end_page += diff * PAGES_PER_WORD;
constexpr u64 base_mask{~0ULL};
for (size_t word_index = start_word; word_index < end_word; word_index++) {
const u64 mask = ExtractBits(base_mask, start_page, end_page);
start_page = 0;
end_page -= PAGES_PER_WORD;
if constexpr (BOOL_BREAK) {
if (func(word_index, mask)) {
return;
}
template <Type type>
RegionBits& GetRegionBits() noexcept {
static_assert(type != Type::Untracked);
if constexpr (type == Type::CPU) {
return cpu;
} else if constexpr (type == Type::GPU) {
return gpu;
} else if constexpr (type == Type::Untracked) {
return untracked;
} else {
func(word_index, mask);
}
static_assert(false, "Invalid type");
}
}
void IteratePages(u64 mask, auto&& func) const {
RENDERER_TRACE;
size_t offset = 0;
while (mask != 0) {
const size_t empty_bits = std::countr_zero(mask);
offset += empty_bits;
mask >>= empty_bits;
const size_t continuous_bits = std::countr_one(mask);
func(offset, continuous_bits);
mask = continuous_bits < PAGES_PER_WORD ? (mask >> continuous_bits) : 0;
offset += continuous_bits;
template <Type type>
const RegionBits& GetRegionBits() const noexcept {
static_assert(type != Type::Untracked);
if constexpr (type == Type::CPU) {
return cpu;
} else if constexpr (type == Type::GPU) {
return gpu;
} else if constexpr (type == Type::Untracked) {
return untracked;
} else {
static_assert(false, "Invalid type");
}
}
@ -113,25 +81,26 @@ public:
*/
template <Type type, bool enable>
void ChangeRegionState(u64 dirty_addr, u64 size) noexcept(type == Type::GPU) {
std::scoped_lock lk{lock};
std::span<u64> state_words = Span<type>();
IterateWords(dirty_addr - cpu_addr, size, [&](size_t index, u64 mask) {
if constexpr (type == Type::CPU) {
UpdateProtection<!enable>(index, untracked[index], mask);
const size_t offset = dirty_addr - cpu_addr;
const size_t start_page = SanitizeAddress(offset) / BYTES_PER_PAGE;
const size_t end_page = Common::DivCeil(SanitizeAddress(offset + size), BYTES_PER_PAGE);
if (start_page >= NUM_REGION_PAGES || end_page <= start_page) {
return;
}
RENDERER_TRACE;
std::unique_lock lk{lock};
static_assert(type != Type::Untracked);
RegionBits& bits = GetRegionBits<type>();
if constexpr (enable) {
state_words[index] |= mask;
if constexpr (type == Type::CPU) {
untracked[index] |= mask;
}
bits.SetRange(start_page, end_page);
} else {
state_words[index] &= ~mask;
bits.UnsetRange(start_page, end_page);
}
if constexpr (type == Type::CPU) {
untracked[index] &= ~mask;
UpdateProtection<!enable>(std::move(lk));
}
}
});
}
/**
* Loop over each page in the given range, turn off those bits and notify the tracker if
@ -144,53 +113,36 @@ public:
template <Type type, bool clear>
void ForEachModifiedRange(VAddr query_cpu_range, s64 size, auto&& func) {
RENDERER_TRACE;
std::scoped_lock lk{lock};
const size_t offset = query_cpu_range - cpu_addr;
const size_t start_page = SanitizeAddress(offset) / BYTES_PER_PAGE;
const size_t end_page = Common::DivCeil(SanitizeAddress(offset + size), BYTES_PER_PAGE);
if (start_page >= NUM_REGION_PAGES || end_page <= start_page) {
return;
}
std::unique_lock lk{lock};
static_assert(type != Type::Untracked);
std::span<u64> state_words = Span<type>();
const size_t offset = query_cpu_range - cpu_addr;
bool pending = false;
size_t pending_offset{};
size_t pending_pointer{};
const auto release = [&]() {
func(cpu_addr + pending_offset * BYTES_PER_PAGE,
(pending_pointer - pending_offset) * BYTES_PER_PAGE);
};
IterateWords(offset, size, [&](size_t index, u64 mask) {
RENDERER_TRACE;
RegionBits& bits = GetRegionBits<type>();
RegionBits mask{};
mask.SetRange(start_page, end_page);
if constexpr (type == Type::GPU) {
mask &= ~untracked[index];
mask &= ~untracked;
}
const u64 word = state_words[index] & mask;
mask &= bits;
if constexpr (clear) {
bits.UnsetRange(start_page, end_page);
if constexpr (type == Type::CPU) {
UpdateProtection<true>(index, untracked[index], mask);
untracked[index] &= ~mask;
UpdateProtection<true>(std::move(lk));
} else {
lk.unlock();
}
state_words[index] &= ~mask;
} else {
lk.unlock();
}
const size_t base_offset = index * PAGES_PER_WORD;
IteratePages(word, [&](size_t pages_offset, size_t pages_size) {
RENDERER_TRACE;
const auto reset = [&]() {
pending_offset = base_offset + pages_offset;
pending_pointer = base_offset + pages_offset + pages_size;
};
if (!pending) {
reset();
pending = true;
return;
}
if (pending_pointer == base_offset + pages_offset) {
pending_pointer += pages_size;
return;
}
release();
reset();
});
});
if (pending) {
release();
for (const auto& [start, end] : mask) {
func(cpu_addr + start * BYTES_PER_PAGE, (end - start) * BYTES_PER_PAGE);
}
}
@ -202,22 +154,23 @@ public:
*/
template <Type type>
[[nodiscard]] bool IsRegionModified(u64 offset, u64 size) const noexcept {
RENDERER_TRACE;
const size_t start_page = SanitizeAddress(offset) / BYTES_PER_PAGE;
const size_t end_page = Common::DivCeil(SanitizeAddress(offset + size), BYTES_PER_PAGE);
if (start_page >= NUM_REGION_PAGES || end_page <= start_page) {
return false;
}
// std::scoped_lock lk{lock}; // Is this needed?
static_assert(type != Type::Untracked);
const std::span<const u64> state_words = Span<type>();
bool result = false;
IterateWords(offset, size, [&](size_t index, u64 mask) {
const RegionBits& bits = GetRegionBits<type>();
RegionBits test{};
test.SetRange(start_page, end_page);
if constexpr (type == Type::GPU) {
mask &= ~untracked[index];
test &= ~untracked;
}
const u64 word = state_words[index] & mask;
if (word != 0) {
result = true;
return true;
}
return false;
});
return result;
test &= bits;
return test.Any();
}
private:
@ -230,37 +183,13 @@ private:
*
* @tparam add_to_tracker True when the tracker should start tracking the new pages
*/
template <bool add_to_tracker>
void UpdateProtection(u64 word_index, u64 current_bits, u64 new_bits) const {
template <bool add_to_tracker, typename Lock>
void UpdateProtection(Lock&& lk) {
RENDERER_TRACE;
u64 changed_bits = (add_to_tracker ? current_bits : ~current_bits) & new_bits;
VAddr addr = cpu_addr + word_index * BYTES_PER_WORD;
IteratePages(changed_bits, [&](size_t offset, size_t size) {
tracker->UpdatePageWatchers<add_to_tracker>(addr + offset * BYTES_PER_PAGE,
size * BYTES_PER_PAGE);
});
}
template <Type type>
std::span<u64> Span() noexcept {
if constexpr (type == Type::CPU) {
return cpu;
} else if constexpr (type == Type::GPU) {
return gpu;
} else if constexpr (type == Type::Untracked) {
return untracked;
}
}
template <Type type>
std::span<const u64> Span() const noexcept {
if constexpr (type == Type::CPU) {
return cpu;
} else if constexpr (type == Type::GPU) {
return gpu;
} else if constexpr (type == Type::Untracked) {
return untracked;
}
RegionBits mask = cpu ^ untracked;
untracked = cpu;
lk.unlock();
tracker->UpdatePageWatchersMasked<add_to_tracker>(cpu_addr, mask);
}
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
@ -270,9 +199,9 @@ private:
#endif
PageManager* tracker;
VAddr cpu_addr = 0;
WordsArray cpu;
WordsArray gpu;
WordsArray untracked;
RegionBits cpu;
RegionBits gpu;
RegionBits untracked;
};
} // namespace VideoCore