early-access version 3527

This commit is contained in:
pineappleEA 2023-04-24 01:59:22 +02:00
parent 4a571b3057
commit a6e49bc8f4
17 changed files with 299 additions and 100 deletions

View File

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 3524. This is the source code for early-access 3527.
## Legal Notice ## Legal Notice

View File

@ -462,7 +462,7 @@ struct Memory::Impl {
} }
if (Settings::IsFastmemEnabled()) { if (Settings::IsFastmemEnabled()) {
const bool is_read_enable = Settings::IsGPULevelHigh() || !cached; const bool is_read_enable = !Settings::IsGPULevelExtreme() || !cached;
system.DeviceMemory().buffer.Protect(vaddr, size, is_read_enable, !cached); system.DeviceMemory().buffer.Protect(vaddr, size, is_read_enable, !cached);
} }

View File

@ -22,7 +22,7 @@ BufferCache<P>::BufferCache(VideoCore::RasterizerInterface& rasterizer_,
void(slot_buffers.insert(runtime, NullBufferParams{})); void(slot_buffers.insert(runtime, NullBufferParams{}));
common_ranges.clear(); common_ranges.clear();
active_async_buffers = IMPLEMENTS_ASYNC_DOWNLOADS && !Settings::IsGPULevelHigh(); active_async_buffers = !Settings::IsGPULevelHigh();
if (!runtime.CanReportMemoryUsage()) { if (!runtime.CanReportMemoryUsage()) {
minimum_memory = DEFAULT_EXPECTED_MEMORY; minimum_memory = DEFAULT_EXPECTED_MEMORY;
@ -74,7 +74,7 @@ void BufferCache<P>::TickFrame() {
uniform_cache_hits[0] = 0; uniform_cache_hits[0] = 0;
uniform_cache_shots[0] = 0; uniform_cache_shots[0] = 0;
active_async_buffers = IMPLEMENTS_ASYNC_DOWNLOADS && !Settings::IsGPULevelHigh(); active_async_buffers = !Settings::IsGPULevelHigh();
const bool skip_preferred = hits * 256 < shots * 251; const bool skip_preferred = hits * 256 < shots * 251;
uniform_buffer_skip_cache_size = skip_preferred ? DEFAULT_SKIP_CACHE_SIZE : 0; uniform_buffer_skip_cache_size = skip_preferred ? DEFAULT_SKIP_CACHE_SIZE : 0;
@ -88,6 +88,13 @@ void BufferCache<P>::TickFrame() {
} }
++frame_tick; ++frame_tick;
delayed_destruction_ring.Tick(); delayed_destruction_ring.Tick();
if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) {
for (auto& buffer : async_buffers_death_ring) {
runtime.FreeDeferredStagingBuffer(buffer);
}
async_buffers_death_ring.clear();
}
} }
template <class P> template <class P>
@ -468,9 +475,11 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
AccumulateFlushes(); AccumulateFlushes();
if (committed_ranges.empty()) { if (committed_ranges.empty()) {
if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) {
if (active_async_buffers) { if (active_async_buffers) {
async_buffers.emplace_back(std::optional<Async_Buffer>{}); async_buffers.emplace_back(std::optional<Async_Buffer>{});
} }
}
return; return;
} }
MICROPROFILE_SCOPE(GPU_DownloadMemory); MICROPROFILE_SCOPE(GPU_DownloadMemory);
@ -529,9 +538,11 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
} }
committed_ranges.clear(); committed_ranges.clear();
if (downloads.empty()) { if (downloads.empty()) {
if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) {
if (active_async_buffers) { if (active_async_buffers) {
async_buffers.emplace_back(std::optional<Async_Buffer>{}); async_buffers.emplace_back(std::optional<Async_Buffer>{});
} }
}
return; return;
} }
if (active_async_buffers) { if (active_async_buffers) {
@ -555,6 +566,9 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
runtime.PostCopyBarrier(); runtime.PostCopyBarrier();
pending_downloads.emplace_back(std::move(normalized_copies)); pending_downloads.emplace_back(std::move(normalized_copies));
async_buffers.emplace_back(download_staging); async_buffers.emplace_back(download_staging);
} else {
committed_ranges.clear();
uncommitted_ranges.clear();
} }
} else { } else {
if constexpr (USE_MEMORY_MAPS) { if constexpr (USE_MEMORY_MAPS) {
@ -629,7 +643,7 @@ void BufferCache<P>::PopAsyncBuffers() {
const IntervalType subtract_interval{cpu_addr, cpu_addr + copy.size}; const IntervalType subtract_interval{cpu_addr, cpu_addr + copy.size};
RemoveEachInOverlapCounter(async_downloads, subtract_interval, -1); RemoveEachInOverlapCounter(async_downloads, subtract_interval, -1);
} }
runtime.FreeDeferredStagingBuffer(*async_buffer); async_buffers_death_ring.emplace_back(*async_buffer);
async_buffers.pop_front(); async_buffers.pop_front();
pending_downloads.pop_front(); pending_downloads.pop_front();
} }

View File

@ -554,11 +554,7 @@ private:
std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads; std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
std::optional<Async_Buffer> current_buffer; std::optional<Async_Buffer> current_buffer;
// queries std::deque<Async_Buffer> async_buffers_death_ring;
boost::container::small_vector<std::pair<VAddr, size_t>, 8> pending_queries;
std::deque<boost::container::small_vector<BufferCopy, 8>> committed_queries;
boost::container::small_vector<u64, 8> flushed_queries;
std::deque<std::optional<Async_Buffer>> query_async_buffers;
size_t immediate_buffer_capacity = 0; size_t immediate_buffer_capacity = 0;
Common::ScratchBuffer<u8> immediate_buffer_alloc; Common::ScratchBuffer<u8> immediate_buffer_alloc;

View File

@ -4,13 +4,20 @@
#pragma once #pragma once
#include <algorithm> #include <algorithm>
#include <condition_variable>
#include <cstring> #include <cstring>
#include <deque> #include <deque>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <mutex>
#include <thread>
#include <queue> #include <queue>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/microprofile.h"
#include "common/scope_exit.h"
#include "common/settings.h"
#include "common/thread.h"
#include "video_core/delayed_destruction_ring.h" #include "video_core/delayed_destruction_ring.h"
#include "video_core/gpu.h" #include "video_core/gpu.h"
#include "video_core/host1x/host1x.h" #include "video_core/host1x/host1x.h"
@ -23,15 +30,26 @@ class FenceBase {
public: public:
explicit FenceBase(bool is_stubbed_) : is_stubbed{is_stubbed_} {} explicit FenceBase(bool is_stubbed_) : is_stubbed{is_stubbed_} {}
bool IsStubbed() const {
return is_stubbed;
}
protected: protected:
bool is_stubbed; bool is_stubbed;
}; };
template <typename TFence, typename TTextureCache, typename TTBufferCache, typename TQueryCache> template <typename Traits>
class FenceManager { class FenceManager {
using TFence = typename Traits::FenceType;
using TTextureCache = typename Traits::TextureCacheType;
using TBufferCache = typename Traits::BufferCacheType;
using TQueryCache = typename Traits::QueryCacheType;
static constexpr bool can_async_check = Traits::HAS_ASYNC_CHECK;
public: public:
/// Notify the fence manager about a new frame /// Notify the fence manager about a new frame
void TickFrame() { void TickFrame() {
std::unique_lock lock(ring_guard);
delayed_destruction_ring.Tick(); delayed_destruction_ring.Tick();
} }
@ -46,17 +64,32 @@ public:
} }
void SignalFence(std::function<void()>&& func) { void SignalFence(std::function<void()>&& func) {
TryReleasePendingFences(); bool delay_fence = Settings::IsGPULevelHigh();
if constexpr (!can_async_check) {
TryReleasePendingFences<false>();
}
const bool should_flush = ShouldFlush(); const bool should_flush = ShouldFlush();
CommitAsyncFlushes(); CommitAsyncFlushes();
uncommitted_operations.emplace_back(std::move(func));
CommitOperations();
TFence new_fence = CreateFence(!should_flush); TFence new_fence = CreateFence(!should_flush);
fences.push(new_fence); if constexpr (can_async_check) {
guard.lock();
}
if (delay_fence) {
uncommitted_operations.emplace_back(std::move(func));
}
pending_operations.emplace_back(std::move(uncommitted_operations));
QueueFence(new_fence); QueueFence(new_fence);
if (!delay_fence) {
func();
}
fences.push(std::move(new_fence));
if (should_flush) { if (should_flush) {
rasterizer.FlushCommands(); rasterizer.FlushCommands();
} }
if constexpr (can_async_check) {
guard.unlock();
cv.notify_all();
}
} }
void SignalSyncPoint(u32 value) { void SignalSyncPoint(u32 value) {
@ -66,29 +99,30 @@ public:
} }
void WaitPendingFences() { void WaitPendingFences() {
while (!fences.empty()) { if constexpr (!can_async_check) {
TFence& current_fence = fences.front(); TryReleasePendingFences<true>();
if (ShouldWait()) {
WaitFence(current_fence);
}
PopAsyncFlushes();
auto operations = std::move(pending_operations.front());
pending_operations.pop_front();
for (auto& operation : operations) {
operation();
}
PopFence();
} }
} }
protected: protected:
explicit FenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_, explicit FenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
TTextureCache& texture_cache_, TTBufferCache& buffer_cache_, TTextureCache& texture_cache_, TBufferCache& buffer_cache_,
TQueryCache& query_cache_) TQueryCache& query_cache_)
: rasterizer{rasterizer_}, gpu{gpu_}, syncpoint_manager{gpu.Host1x().GetSyncpointManager()}, : rasterizer{rasterizer_}, gpu{gpu_}, syncpoint_manager{gpu.Host1x().GetSyncpointManager()},
texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, query_cache{query_cache_} {} texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, query_cache{query_cache_} {
if constexpr (can_async_check) {
fence_thread =
std::jthread([this](std::stop_token token) { ReleaseThreadFunc(token); });
}
}
virtual ~FenceManager() = default; virtual ~FenceManager() {
if constexpr (can_async_check) {
fence_thread.request_stop();
cv.notify_all();
fence_thread.join();
}
}
/// Creates a Fence Interface, does not create a backend fence if 'is_stubbed' is /// Creates a Fence Interface, does not create a backend fence if 'is_stubbed' is
/// true /// true
@ -104,23 +138,70 @@ protected:
Tegra::GPU& gpu; Tegra::GPU& gpu;
Tegra::Host1x::SyncpointManager& syncpoint_manager; Tegra::Host1x::SyncpointManager& syncpoint_manager;
TTextureCache& texture_cache; TTextureCache& texture_cache;
TTBufferCache& buffer_cache; TBufferCache& buffer_cache;
TQueryCache& query_cache; TQueryCache& query_cache;
private: private:
template <bool force_wait>
void TryReleasePendingFences() { void TryReleasePendingFences() {
while (!fences.empty()) { while (!fences.empty()) {
TFence& current_fence = fences.front(); TFence& current_fence = fences.front();
if (ShouldWait() && !IsFenceSignaled(current_fence)) { if (ShouldWait() && !IsFenceSignaled(current_fence)) {
if constexpr (force_wait) {
WaitFence(current_fence);
} else {
return; return;
} }
}
PopAsyncFlushes(); PopAsyncFlushes();
auto operations = std::move(pending_operations.front()); auto operations = std::move(pending_operations.front());
pending_operations.pop_front(); pending_operations.pop_front();
for (auto& operation : operations) { for (auto& operation : operations) {
operation(); operation();
} }
PopFence(); {
std::unique_lock lock(ring_guard);
delayed_destruction_ring.Push(std::move(current_fence));
}
fences.pop();
}
}
void ReleaseThreadFunc(std::stop_token stop_token) {
std::string name = "GPUFencingThread";
MicroProfileOnThreadCreate(name.c_str());
// Cleanup
SCOPE_EXIT({ MicroProfileOnThreadExit(); });
Common::SetCurrentThreadName(name.c_str());
Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
TFence current_fence;
std::deque<std::function<void()>> current_operations;
while (!stop_token.stop_requested()) {
{
std::unique_lock lock(guard);
cv.wait(lock, [&] { return stop_token.stop_requested() || !fences.empty(); });
if (stop_token.stop_requested()) [[unlikely]] {
return;
}
current_fence = std::move(fences.front());
current_operations = std::move(pending_operations.front());
fences.pop();
pending_operations.pop_front();
}
if (!current_fence->IsStubbed()) {
WaitFence(current_fence);
}
PopAsyncFlushes();
for (auto& operation : current_operations) {
operation();
}
{
std::unique_lock lock(ring_guard);
delayed_destruction_ring.Push(std::move(current_fence));
}
} }
} }
@ -154,19 +235,16 @@ private:
query_cache.CommitAsyncFlushes(); query_cache.CommitAsyncFlushes();
} }
void PopFence() {
delayed_destruction_ring.Push(std::move(fences.front()));
fences.pop();
}
void CommitOperations() {
pending_operations.emplace_back(std::move(uncommitted_operations));
}
std::queue<TFence> fences; std::queue<TFence> fences;
std::deque<std::function<void()>> uncommitted_operations; std::deque<std::function<void()>> uncommitted_operations;
std::deque<std::deque<std::function<void()>>> pending_operations; std::deque<std::deque<std::function<void()>>> pending_operations;
std::mutex guard;
std::mutex ring_guard;
std::condition_variable cv;
std::jthread fence_thread;
DelayedDestructionRing<TFence, 6> delayed_destruction_ring; DelayedDestructionRing<TFence, 6> delayed_destruction_ring;
}; };

View File

@ -6,6 +6,7 @@
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cstring> #include <cstring>
#include <functional>
#include <iterator> #include <iterator>
#include <list> #include <list>
#include <memory> #include <memory>
@ -17,13 +18,19 @@
#include "common/assert.h" #include "common/assert.h"
#include "common/settings.h" #include "common/settings.h"
#include "core/memory.h"
#include "video_core/control/channel_state_cache.h" #include "video_core/control/channel_state_cache.h"
#include "video_core/engines/maxwell_3d.h" #include "video_core/engines/maxwell_3d.h"
#include "video_core/memory_manager.h" #include "video_core/memory_manager.h"
#include "video_core/rasterizer_interface.h" #include "video_core/rasterizer_interface.h"
#include "video_core/texture_cache/slot_vector.h"
namespace VideoCommon { namespace VideoCommon {
using AsyncJobId = SlotId;
static constexpr AsyncJobId NULL_ASYNC_JOB_ID{0};
template <class QueryCache, class HostCounter> template <class QueryCache, class HostCounter>
class CounterStreamBase { class CounterStreamBase {
public: public:
@ -93,9 +100,13 @@ private:
template <class QueryCache, class CachedQuery, class CounterStream, class HostCounter> template <class QueryCache, class CachedQuery, class CounterStream, class HostCounter>
class QueryCacheBase : public VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo> { class QueryCacheBase : public VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo> {
public: public:
explicit QueryCacheBase(VideoCore::RasterizerInterface& rasterizer_) explicit QueryCacheBase(VideoCore::RasterizerInterface& rasterizer_,
: rasterizer{rasterizer_}, streams{{CounterStream{static_cast<QueryCache&>(*this), Core::Memory::Memory& cpu_memory_)
VideoCore::QueryType::SamplesPassed}}} {} : rasterizer{rasterizer_},
cpu_memory{cpu_memory_}, streams{{CounterStream{static_cast<QueryCache&>(*this),
VideoCore::QueryType::SamplesPassed}}} {
(void)slot_async_jobs.insert(); // Null value
}
void InvalidateRegion(VAddr addr, std::size_t size) { void InvalidateRegion(VAddr addr, std::size_t size) {
std::unique_lock lock{mutex}; std::unique_lock lock{mutex};
@ -126,10 +137,15 @@ public:
query = Register(type, *cpu_addr, host_ptr, timestamp.has_value()); query = Register(type, *cpu_addr, host_ptr, timestamp.has_value());
} }
query->BindCounter(Stream(type).Current(), timestamp); auto result = query->BindCounter(Stream(type).Current());
if (Settings::values.use_asynchronous_gpu_emulation.GetValue()) { if (result) {
AsyncFlushQuery(*cpu_addr); auto async_job_id = query->GetAsyncJob();
auto& async_job = slot_async_jobs[async_job_id];
async_job.collected = true;
async_job.value = *result;
query->SetAsyncJob(NULL_ASYNC_JOB_ID);
} }
AsyncFlushQuery(query, timestamp, lock);
} }
/// Updates counters from GPU state. Expected to be called once per draw, clear or dispatch. /// Updates counters from GPU state. Expected to be called once per draw, clear or dispatch.
@ -173,15 +189,18 @@ public:
} }
void CommitAsyncFlushes() { void CommitAsyncFlushes() {
std::unique_lock lock{mutex};
committed_flushes.push_back(uncommitted_flushes); committed_flushes.push_back(uncommitted_flushes);
uncommitted_flushes.reset(); uncommitted_flushes.reset();
} }
bool HasUncommittedFlushes() const { bool HasUncommittedFlushes() const {
std::unique_lock lock{mutex};
return uncommitted_flushes != nullptr; return uncommitted_flushes != nullptr;
} }
bool ShouldWaitAsyncFlushes() const { bool ShouldWaitAsyncFlushes() const {
std::unique_lock lock{mutex};
if (committed_flushes.empty()) { if (committed_flushes.empty()) {
return false; return false;
} }
@ -189,6 +208,7 @@ public:
} }
void PopAsyncFlushes() { void PopAsyncFlushes() {
std::unique_lock lock{mutex};
if (committed_flushes.empty()) { if (committed_flushes.empty()) {
return; return;
} }
@ -197,15 +217,25 @@ public:
committed_flushes.pop_front(); committed_flushes.pop_front();
return; return;
} }
for (VAddr query_address : *flush_list) { for (AsyncJobId async_job_id : *flush_list) {
FlushAndRemoveRegion(query_address, 4); AsyncJob& async_job = slot_async_jobs[async_job_id];
if (!async_job.collected) {
FlushAndRemoveRegion(async_job.query_location, 2, true);
}
} }
committed_flushes.pop_front(); committed_flushes.pop_front();
} }
private: private:
struct AsyncJob {
bool collected = false;
u64 value = 0;
VAddr query_location = 0;
std::optional<u64> timestamp{};
};
/// Flushes a memory range to guest memory and removes it from the cache. /// Flushes a memory range to guest memory and removes it from the cache.
void FlushAndRemoveRegion(VAddr addr, std::size_t size) { void FlushAndRemoveRegion(VAddr addr, std::size_t size, bool async = false) {
const u64 addr_begin = addr; const u64 addr_begin = addr;
const u64 addr_end = addr_begin + size; const u64 addr_end = addr_begin + size;
const auto in_range = [addr_begin, addr_end](const CachedQuery& query) { const auto in_range = [addr_begin, addr_end](const CachedQuery& query) {
@ -226,7 +256,16 @@ private:
continue; continue;
} }
rasterizer.UpdatePagesCachedCount(query.GetCpuAddr(), query.SizeInBytes(), -1); rasterizer.UpdatePagesCachedCount(query.GetCpuAddr(), query.SizeInBytes(), -1);
query.Flush(); AsyncJobId async_job_id = query.GetAsyncJob();
auto flush_result = query.Flush(async);
if (async_job_id == NULL_ASYNC_JOB_ID) {
ASSERT_MSG(false, "This should not be reachable at all");
continue;
}
AsyncJob& async_job = slot_async_jobs[async_job_id];
async_job.collected = true;
async_job.value = flush_result;
query.SetAsyncJob(NULL_ASYNC_JOB_ID);
} }
std::erase_if(contents, in_range); std::erase_if(contents, in_range);
} }
@ -253,26 +292,54 @@ private:
return found != std::end(contents) ? &*found : nullptr; return found != std::end(contents) ? &*found : nullptr;
} }
void AsyncFlushQuery(VAddr addr) { void AsyncFlushQuery(CachedQuery* query, std::optional<u64> timestamp,
std::unique_lock<std::recursive_mutex>& lock) {
const AsyncJobId new_async_job_id = slot_async_jobs.insert();
{
AsyncJob& async_job = slot_async_jobs[new_async_job_id];
query->SetAsyncJob(new_async_job_id);
async_job.query_location = query->GetCpuAddr();
async_job.collected = false;
if (!uncommitted_flushes) { if (!uncommitted_flushes) {
uncommitted_flushes = std::make_shared<std::vector<VAddr>>(); uncommitted_flushes = std::make_shared<std::vector<AsyncJobId>>();
} }
uncommitted_flushes->push_back(addr); uncommitted_flushes->push_back(new_async_job_id);
}
lock.unlock();
std::function<void()> operation([this, new_async_job_id, timestamp] {
std::unique_lock local_lock{mutex};
AsyncJob& async_job = slot_async_jobs[new_async_job_id];
if (timestamp) {
u64 timestamp_value = *timestamp;
cpu_memory.WriteBlockUnsafe(async_job.query_location + sizeof(u64),
&timestamp_value, sizeof(8));
cpu_memory.WriteBlockUnsafe(async_job.query_location, &async_job.value, sizeof(8));
} else {
u32 small_value = static_cast<u32>(async_job.value);
cpu_memory.WriteBlockUnsafe(async_job.query_location, &small_value, sizeof(u32));
}
slot_async_jobs.erase(new_async_job_id);
});
rasterizer.SyncOperation(std::move(operation));
} }
static constexpr std::uintptr_t YUZU_PAGESIZE = 4096; static constexpr std::uintptr_t YUZU_PAGESIZE = 4096;
static constexpr unsigned YUZU_PAGEBITS = 12; static constexpr unsigned YUZU_PAGEBITS = 12;
VideoCore::RasterizerInterface& rasterizer; SlotVector<AsyncJob> slot_async_jobs;
std::recursive_mutex mutex; VideoCore::RasterizerInterface& rasterizer;
Core::Memory::Memory& cpu_memory;
mutable std::recursive_mutex mutex;
std::unordered_map<u64, std::vector<CachedQuery>> cached_queries; std::unordered_map<u64, std::vector<CachedQuery>> cached_queries;
std::array<CounterStream, VideoCore::NumQueryTypes> streams; std::array<CounterStream, VideoCore::NumQueryTypes> streams;
std::shared_ptr<std::vector<VAddr>> uncommitted_flushes{}; std::shared_ptr<std::vector<AsyncJobId>> uncommitted_flushes{};
std::list<std::shared_ptr<std::vector<VAddr>>> committed_flushes; std::list<std::shared_ptr<std::vector<AsyncJobId>>> committed_flushes;
}; };
template <class QueryCache, class HostCounter> template <class QueryCache, class HostCounter>
@ -291,12 +358,12 @@ public:
virtual ~HostCounterBase() = default; virtual ~HostCounterBase() = default;
/// Returns the current value of the query. /// Returns the current value of the query.
u64 Query() { u64 Query(bool async = false) {
if (result) { if (result) {
return *result; return *result;
} }
u64 value = BlockingQuery() + base_result; u64 value = BlockingQuery(async) + base_result;
if (dependency) { if (dependency) {
value += dependency->Query(); value += dependency->Query();
dependency = nullptr; dependency = nullptr;
@ -317,7 +384,7 @@ public:
protected: protected:
/// Returns the value of query from the backend API blocking as needed. /// Returns the value of query from the backend API blocking as needed.
virtual u64 BlockingQuery() const = 0; virtual u64 BlockingQuery(bool async = false) const = 0;
private: private:
std::shared_ptr<HostCounter> dependency; ///< Counter to add to this value. std::shared_ptr<HostCounter> dependency; ///< Counter to add to this value.
@ -340,26 +407,23 @@ public:
CachedQueryBase& operator=(const CachedQueryBase&) = delete; CachedQueryBase& operator=(const CachedQueryBase&) = delete;
/// Flushes the query to guest memory. /// Flushes the query to guest memory.
virtual void Flush() { virtual u64 Flush(bool async = false) {
// When counter is nullptr it means that it's just been reset. We are supposed to write a // When counter is nullptr it means that it's just been reset. We are supposed to write a
// zero in these cases. // zero in these cases.
const u64 value = counter ? counter->Query() : 0; const u64 value = counter ? counter->Query(async) : 0;
std::memcpy(host_ptr, &value, sizeof(u64)); return value;
if (timestamp) {
std::memcpy(host_ptr + TIMESTAMP_OFFSET, &*timestamp, sizeof(u64));
}
} }
/// Binds a counter to this query. /// Binds a counter to this query.
void BindCounter(std::shared_ptr<HostCounter> counter_, std::optional<u64> timestamp_) { std::optional<u64> BindCounter(std::shared_ptr<HostCounter> counter_) {
std::optional<u64> result{};
if (counter) { if (counter) {
// If there's an old counter set it means the query is being rewritten by the game. // If there's an old counter set it means the query is being rewritten by the game.
// To avoid losing the data forever, flush here. // To avoid losing the data forever, flush here.
Flush(); result = std::make_optional(Flush());
} }
counter = std::move(counter_); counter = std::move(counter_);
timestamp = timestamp_; return result;
} }
VAddr GetCpuAddr() const noexcept { VAddr GetCpuAddr() const noexcept {
@ -374,6 +438,14 @@ public:
return with_timestamp ? LARGE_QUERY_SIZE : SMALL_QUERY_SIZE; return with_timestamp ? LARGE_QUERY_SIZE : SMALL_QUERY_SIZE;
} }
void SetAsyncJob(AsyncJobId assigned_async_job_) {
assigned_async_job = assigned_async_job_;
}
AsyncJobId GetAsyncJob() const {
return assigned_async_job;
}
protected: protected:
/// Returns true when querying the counter may potentially block. /// Returns true when querying the counter may potentially block.
bool WaitPending() const noexcept { bool WaitPending() const noexcept {
@ -389,6 +461,7 @@ private:
u8* host_ptr; ///< Writable host pointer. u8* host_ptr; ///< Writable host pointer.
std::shared_ptr<HostCounter> counter; ///< Host counter to query, owns the dependency tree. std::shared_ptr<HostCounter> counter; ///< Host counter to query, owns the dependency tree.
std::optional<u64> timestamp; ///< Timestamp to flush to guest memory. std::optional<u64> timestamp; ///< Timestamp to flush to guest memory.
AsyncJobId assigned_async_job;
}; };
} // namespace VideoCommon } // namespace VideoCommon

View File

@ -30,7 +30,17 @@ private:
}; };
using Fence = std::shared_ptr<GLInnerFence>; using Fence = std::shared_ptr<GLInnerFence>;
using GenericFenceManager = VideoCommon::FenceManager<Fence, TextureCache, BufferCache, QueryCache>;
struct FenceManagerParams {
using FenceType = Fence;
using BufferCacheType = BufferCache;
using TextureCacheType = TextureCache;
using QueryCacheType = QueryCache;
static constexpr bool HAS_ASYNC_CHECK = false;
};
using GenericFenceManager = VideoCommon::FenceManager<FenceManagerParams>;
class FenceManagerOpenGL final : public GenericFenceManager { class FenceManagerOpenGL final : public GenericFenceManager {
public: public:

View File

@ -26,8 +26,8 @@ constexpr GLenum GetTarget(VideoCore::QueryType type) {
} // Anonymous namespace } // Anonymous namespace
QueryCache::QueryCache(RasterizerOpenGL& rasterizer_) QueryCache::QueryCache(RasterizerOpenGL& rasterizer_, Core::Memory::Memory& cpu_memory_)
: QueryCacheBase(rasterizer_), gl_rasterizer{rasterizer_} {} : QueryCacheBase(rasterizer_, cpu_memory_), gl_rasterizer{rasterizer_} {}
QueryCache::~QueryCache() = default; QueryCache::~QueryCache() = default;
@ -74,7 +74,7 @@ void HostCounter::EndQuery() {
glEndQuery(GetTarget(type)); glEndQuery(GetTarget(type));
} }
u64 HostCounter::BlockingQuery() const { u64 HostCounter::BlockingQuery([[maybe_unused]] bool async) const {
GLint64 value; GLint64 value;
glGetQueryObjecti64v(query.handle, GL_QUERY_RESULT, &value); glGetQueryObjecti64v(query.handle, GL_QUERY_RESULT, &value);
return static_cast<u64>(value); return static_cast<u64>(value);
@ -96,7 +96,7 @@ CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
return *this; return *this;
} }
void CachedQuery::Flush() { u64 CachedQuery::Flush([[maybe_unused]] bool async) {
// Waiting for a query while another query of the same target is enabled locks Nvidia's driver. // Waiting for a query while another query of the same target is enabled locks Nvidia's driver.
// To avoid this disable and re-enable keeping the dependency stream. // To avoid this disable and re-enable keeping the dependency stream.
// But we only have to do this if we have pending waits to be done. // But we only have to do this if we have pending waits to be done.
@ -106,11 +106,13 @@ void CachedQuery::Flush() {
stream.Update(false); stream.Update(false);
} }
VideoCommon::CachedQueryBase<HostCounter>::Flush(); auto result = VideoCommon::CachedQueryBase<HostCounter>::Flush();
if (slice_counter) { if (slice_counter) {
stream.Update(true); stream.Update(true);
} }
return result;
} }
} // namespace OpenGL } // namespace OpenGL

View File

@ -28,7 +28,7 @@ using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
class QueryCache final class QueryCache final
: public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> { : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
public: public:
explicit QueryCache(RasterizerOpenGL& rasterizer_); explicit QueryCache(RasterizerOpenGL& rasterizer_, Core::Memory::Memory& cpu_memory_);
~QueryCache(); ~QueryCache();
OGLQuery AllocateQuery(VideoCore::QueryType type); OGLQuery AllocateQuery(VideoCore::QueryType type);
@ -51,7 +51,7 @@ public:
void EndQuery(); void EndQuery();
private: private:
u64 BlockingQuery() const override; u64 BlockingQuery(bool async = false) const override;
QueryCache& cache; QueryCache& cache;
const VideoCore::QueryType type; const VideoCore::QueryType type;
@ -70,7 +70,7 @@ public:
CachedQuery(const CachedQuery&) = delete; CachedQuery(const CachedQuery&) = delete;
CachedQuery& operator=(const CachedQuery&) = delete; CachedQuery& operator=(const CachedQuery&) = delete;
void Flush() override; u64 Flush(bool async = false) override;
private: private:
QueryCache* cache; QueryCache* cache;

View File

@ -63,7 +63,7 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra
buffer_cache(*this, cpu_memory_, buffer_cache_runtime), buffer_cache(*this, cpu_memory_, buffer_cache_runtime),
shader_cache(*this, emu_window_, device, texture_cache, buffer_cache, program_manager, shader_cache(*this, emu_window_, device, texture_cache, buffer_cache, program_manager,
state_tracker, gpu.ShaderNotify()), state_tracker, gpu.ShaderNotify()),
query_cache(*this), accelerate_dma(buffer_cache, texture_cache), query_cache(*this, cpu_memory_), accelerate_dma(buffer_cache, texture_cache),
fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache), fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache),
blit_image(program_manager_) {} blit_image(program_manager_) {}

View File

@ -5,6 +5,7 @@
#include "video_core/renderer_vulkan/vk_buffer_cache.h" #include "video_core/renderer_vulkan/vk_buffer_cache.h"
#include "video_core/renderer_vulkan/vk_fence_manager.h" #include "video_core/renderer_vulkan/vk_fence_manager.h"
#include "video_core/renderer_vulkan/vk_query_cache.h"
#include "video_core/renderer_vulkan/vk_scheduler.h" #include "video_core/renderer_vulkan/vk_scheduler.h"
#include "video_core/renderer_vulkan/vk_texture_cache.h" #include "video_core/renderer_vulkan/vk_texture_cache.h"
#include "video_core/vulkan_common/vulkan_device.h" #include "video_core/vulkan_common/vulkan_device.h"

View File

@ -40,7 +40,16 @@ private:
}; };
using Fence = std::shared_ptr<InnerFence>; using Fence = std::shared_ptr<InnerFence>;
using GenericFenceManager = VideoCommon::FenceManager<Fence, TextureCache, BufferCache, QueryCache>; struct FenceManagerParams {
using FenceType = Fence;
using BufferCacheType = BufferCache;
using TextureCacheType = TextureCache;
using QueryCacheType = QueryCache;
static constexpr bool HAS_ASYNC_CHECK = true;
};
using GenericFenceManager = VideoCommon::FenceManager<FenceManagerParams>;
class FenceManager final : public GenericFenceManager { class FenceManager final : public GenericFenceManager {
public: public:

View File

@ -66,9 +66,10 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
} }
} }
QueryCache::QueryCache(VideoCore::RasterizerInterface& rasterizer_, const Device& device_, QueryCache::QueryCache(VideoCore::RasterizerInterface& rasterizer_,
Core::Memory::Memory& cpu_memory_, const Device& device_,
Scheduler& scheduler_) Scheduler& scheduler_)
: QueryCacheBase{rasterizer_}, device{device_}, scheduler{scheduler_}, : QueryCacheBase{rasterizer_, cpu_memory_}, device{device_}, scheduler{scheduler_},
query_pools{ query_pools{
QueryPool{device_, scheduler_, QueryType::SamplesPassed}, QueryPool{device_, scheduler_, QueryType::SamplesPassed},
} {} } {}
@ -98,8 +99,10 @@ HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> depend
query{cache_.AllocateQuery(type_)}, tick{cache_.GetScheduler().CurrentTick()} { query{cache_.AllocateQuery(type_)}, tick{cache_.GetScheduler().CurrentTick()} {
const vk::Device* logical = &cache.GetDevice().GetLogical(); const vk::Device* logical = &cache.GetDevice().GetLogical();
cache.GetScheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) { cache.GetScheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
const bool use_precise = Settings::IsGPULevelHigh();
logical->ResetQueryPool(query.first, query.second, 1); logical->ResetQueryPool(query.first, query.second, 1);
cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT); cmdbuf.BeginQuery(query.first, query.second,
use_precise ? VK_QUERY_CONTROL_PRECISE_BIT : 0);
}); });
} }
@ -112,8 +115,10 @@ void HostCounter::EndQuery() {
[query = query](vk::CommandBuffer cmdbuf) { cmdbuf.EndQuery(query.first, query.second); }); [query = query](vk::CommandBuffer cmdbuf) { cmdbuf.EndQuery(query.first, query.second); });
} }
u64 HostCounter::BlockingQuery() const { u64 HostCounter::BlockingQuery(bool async) const {
if (!async) {
cache.GetScheduler().Wait(tick); cache.GetScheduler().Wait(tick);
}
u64 data; u64 data;
const VkResult query_result = cache.GetDevice().GetLogical().GetQueryResults( const VkResult query_result = cache.GetDevice().GetLogical().GetQueryResults(
query.first, query.second, 1, sizeof(data), &data, sizeof(data), query.first, query.second, 1, sizeof(data), &data, sizeof(data),

View File

@ -52,7 +52,8 @@ private:
class QueryCache final class QueryCache final
: public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> { : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
public: public:
explicit QueryCache(VideoCore::RasterizerInterface& rasterizer_, const Device& device_, explicit QueryCache(VideoCore::RasterizerInterface& rasterizer_,
Core::Memory::Memory& cpu_memory_, const Device& device_,
Scheduler& scheduler_); Scheduler& scheduler_);
~QueryCache(); ~QueryCache();
@ -83,7 +84,7 @@ public:
void EndQuery(); void EndQuery();
private: private:
u64 BlockingQuery() const override; u64 BlockingQuery(bool async = false) const override;
QueryCache& cache; QueryCache& cache;
const VideoCore::QueryType type; const VideoCore::QueryType type;

View File

@ -172,7 +172,8 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
buffer_cache(*this, cpu_memory_, buffer_cache_runtime), buffer_cache(*this, cpu_memory_, buffer_cache_runtime),
pipeline_cache(*this, device, scheduler, descriptor_pool, update_descriptor_queue, pipeline_cache(*this, device, scheduler, descriptor_pool, update_descriptor_queue,
render_pass_cache, buffer_cache, texture_cache, gpu.ShaderNotify()), render_pass_cache, buffer_cache, texture_cache, gpu.ShaderNotify()),
query_cache{*this, device, scheduler}, accelerate_dma(buffer_cache, texture_cache, scheduler), query_cache{*this, cpu_memory_, device, scheduler},
accelerate_dma(buffer_cache, texture_cache, scheduler),
fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler), fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
wfi_event(device.GetLogical().CreateEvent()) { wfi_event(device.GetLogical().CreateEvent()) {
scheduler.SetQueryCache(query_cache); scheduler.SetQueryCache(query_cache);
@ -675,7 +676,8 @@ bool RasterizerVulkan::AccelerateConditionalRendering() {
const GPUVAddr condition_address{maxwell3d->regs.render_enable.Address()}; const GPUVAddr condition_address{maxwell3d->regs.render_enable.Address()};
Maxwell::ReportSemaphore::Compare cmp; Maxwell::ReportSemaphore::Compare cmp;
if (gpu_memory->IsMemoryDirty(condition_address, sizeof(cmp), if (gpu_memory->IsMemoryDirty(condition_address, sizeof(cmp),
VideoCommon::CacheType::BufferCache)) { VideoCommon::CacheType::BufferCache |
VideoCommon::CacheType::QueryCache)) {
return true; return true;
} }
return false; return false;

View File

@ -139,6 +139,13 @@ void TextureCache<P>::TickFrame() {
runtime.TickFrame(); runtime.TickFrame();
critical_gc = 0; critical_gc = 0;
++frame_tick; ++frame_tick;
if constexpr (IMPLEMENTS_ASYNC_DOWNLOADS) {
for (auto& buffer : async_buffers_death_ring) {
runtime.FreeDeferredStagingBuffer(buffer);
}
async_buffers_death_ring.clear();
}
} }
template <class P> template <class P>
@ -688,10 +695,10 @@ void TextureCache<P>::CommitAsyncFlushes() {
} }
uncommitted_async_buffers.emplace_back(download_map); uncommitted_async_buffers.emplace_back(download_map);
} }
}
committed_downloads.emplace_back(std::move(uncommitted_downloads));
async_buffers.emplace_back(std::move(uncommitted_async_buffers)); async_buffers.emplace_back(std::move(uncommitted_async_buffers));
uncommitted_async_buffers.clear(); uncommitted_async_buffers.clear();
}
committed_downloads.emplace_back(std::move(uncommitted_downloads));
uncommitted_downloads.clear(); uncommitted_downloads.clear();
} }
@ -729,7 +736,7 @@ void TextureCache<P>::PopAsyncFlushes() {
} }
} }
for (auto& download_buffer : download_map) { for (auto& download_buffer : download_map) {
runtime.FreeDeferredStagingBuffer(download_buffer); async_buffers_death_ring.emplace_back(download_buffer);
} }
committed_downloads.pop_front(); committed_downloads.pop_front();
async_buffers.pop_front(); async_buffers.pop_front();

View File

@ -449,6 +449,7 @@ private:
std::deque<std::vector<PendingDownload>> committed_downloads; std::deque<std::vector<PendingDownload>> committed_downloads;
std::vector<AsyncBuffer> uncommitted_async_buffers; std::vector<AsyncBuffer> uncommitted_async_buffers;
std::deque<std::vector<AsyncBuffer>> async_buffers; std::deque<std::vector<AsyncBuffer>> async_buffers;
std::deque<AsyncBuffer> async_buffers_death_ring;
struct LRUItemParams { struct LRUItemParams {
using ObjectType = ImageId; using ObjectType = ImageId;