diff options
Diffstat (limited to 'Source/Core/VideoCommon/Fifo.cpp')
| -rw-r--r-- | Source/Core/VideoCommon/Fifo.cpp | 391 |
1 files changed, 174 insertions, 217 deletions
diff --git a/Source/Core/VideoCommon/Fifo.cpp b/Source/Core/VideoCommon/Fifo.cpp index 617a9d73f7..d222157b93 100644 --- a/Source/Core/VideoCommon/Fifo.cpp +++ b/Source/Core/VideoCommon/Fifo.cpp @@ -34,88 +34,47 @@ namespace Fifo { -static constexpr u32 FIFO_SIZE = 2 * 1024 * 1024; static constexpr int GPU_TIME_SLOT_SIZE = 1000; -static Common::BlockingLoop s_gpu_mainloop; - -static Common::Flag s_emu_running_state; - -// Most of this array is unlikely to be faulted in... -static u8 s_fifo_aux_data[FIFO_SIZE]; -static u8* s_fifo_aux_write_ptr; -static u8* s_fifo_aux_read_ptr; - -// This could be in SConfig, but it depends on multiple settings -// and can change at runtime. -static bool s_use_deterministic_gpu_thread; - -static CoreTiming::EventType* s_event_sync_gpu; - -// STATE_TO_SAVE -static u8* s_video_buffer; -static u8* s_video_buffer_read_ptr; -static std::atomic<u8*> s_video_buffer_write_ptr; -static std::atomic<u8*> s_video_buffer_seen_ptr; -static u8* s_video_buffer_pp_read_ptr; -// The read_ptr is always owned by the GPU thread. In normal mode, so is the -// write_ptr, despite it being atomic. In deterministic GPU thread mode, -// things get a bit more complicated: -// - The seen_ptr is written by the GPU thread, and points to what it's already -// processed as much of as possible - in the case of a partial command which -// caused it to stop, not the same as the read ptr. It's written by the GPU, -// under the lock, and updating the cond. -// - The write_ptr is written by the CPU thread after it copies data from the -// FIFO. Maybe someday it will be under the lock. For now, because RunGpuLoop -// polls, it's just atomic. -// - The pp_read_ptr is the CPU preprocessing version of the read_ptr. - -static std::atomic<int> s_sync_ticks; -static bool s_syncing_suspended; -static Common::Event s_sync_wakeup_event; - -static std::optional<size_t> s_config_callback_id = std::nullopt; -static bool s_config_sync_gpu = false; -static int s_config_sync_gpu_max_distance = 0; -static int s_config_sync_gpu_min_distance = 0; -static float s_config_sync_gpu_overclock = 0.0f; - -static void RefreshConfig() +FifoManager::FifoManager() = default; +FifoManager::~FifoManager() = default; + +void FifoManager::RefreshConfig() { - s_config_sync_gpu = Config::Get(Config::MAIN_SYNC_GPU); - s_config_sync_gpu_max_distance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE); - s_config_sync_gpu_min_distance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE); - s_config_sync_gpu_overclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK); + m_config_sync_gpu = Config::Get(Config::MAIN_SYNC_GPU); + m_config_sync_gpu_max_distance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE); + m_config_sync_gpu_min_distance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE); + m_config_sync_gpu_overclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK); } -void DoState(PointerWrap& p) +void FifoManager::DoState(PointerWrap& p) { - p.DoArray(s_video_buffer, FIFO_SIZE); - u8* write_ptr = s_video_buffer_write_ptr; - p.DoPointer(write_ptr, s_video_buffer); - s_video_buffer_write_ptr = write_ptr; - p.DoPointer(s_video_buffer_read_ptr, s_video_buffer); - if (p.IsReadMode() && s_use_deterministic_gpu_thread) + p.DoArray(m_video_buffer, FIFO_SIZE); + u8* write_ptr = m_video_buffer_write_ptr; + p.DoPointer(write_ptr, m_video_buffer); + m_video_buffer_write_ptr = write_ptr; + p.DoPointer(m_video_buffer_read_ptr, m_video_buffer); + if (p.IsReadMode() && m_use_deterministic_gpu_thread) { // We're good and paused, right? - s_video_buffer_seen_ptr = s_video_buffer_pp_read_ptr = s_video_buffer_read_ptr; + m_video_buffer_seen_ptr = m_video_buffer_pp_read_ptr = m_video_buffer_read_ptr; } - p.Do(s_sync_ticks); - p.Do(s_syncing_suspended); + p.Do(m_sync_ticks); + p.Do(m_syncing_suspended); } -void PauseAndLock(bool doLock, bool unpauseOnUnlock) +void FifoManager::PauseAndLock(bool doLock, bool unpauseOnUnlock) { if (doLock) { SyncGPU(SyncGPUReason::Other); EmulatorState(false); - if (!Core::System::GetInstance().IsDualCoreMode() || s_use_deterministic_gpu_thread) + if (!Core::System::GetInstance().IsDualCoreMode() || m_use_deterministic_gpu_thread) return; - s_gpu_mainloop.WaitYield(std::chrono::milliseconds(100), Host_YieldToUI); + m_gpu_mainloop.WaitYield(std::chrono::milliseconds(100), Host_YieldToUI); } else { @@ -124,44 +83,44 @@ void PauseAndLock(bool doLock, bool unpauseOnUnlock) } } -void Init() +void FifoManager::Init() { - if (!s_config_callback_id) - s_config_callback_id = Config::AddConfigChangedCallback(RefreshConfig); + if (!m_config_callback_id) + m_config_callback_id = Config::AddConfigChangedCallback([this] { RefreshConfig(); }); RefreshConfig(); // Padded so that SIMD overreads in the vertex loader are safe - s_video_buffer = static_cast<u8*>(Common::AllocateMemoryPages(FIFO_SIZE + 4)); + m_video_buffer = static_cast<u8*>(Common::AllocateMemoryPages(FIFO_SIZE + 4)); ResetVideoBuffer(); if (Core::System::GetInstance().IsDualCoreMode()) - s_gpu_mainloop.Prepare(); - s_sync_ticks.store(0); + m_gpu_mainloop.Prepare(); + m_sync_ticks.store(0); } -void Shutdown() +void FifoManager::Shutdown() { - if (s_gpu_mainloop.IsRunning()) + if (m_gpu_mainloop.IsRunning()) PanicAlertFmt("FIFO shutting down while active"); - Common::FreeMemoryPages(s_video_buffer, FIFO_SIZE + 4); - s_video_buffer = nullptr; - s_video_buffer_write_ptr = nullptr; - s_video_buffer_pp_read_ptr = nullptr; - s_video_buffer_read_ptr = nullptr; - s_video_buffer_seen_ptr = nullptr; - s_fifo_aux_write_ptr = nullptr; - s_fifo_aux_read_ptr = nullptr; + Common::FreeMemoryPages(m_video_buffer, FIFO_SIZE + 4); + m_video_buffer = nullptr; + m_video_buffer_write_ptr = nullptr; + m_video_buffer_pp_read_ptr = nullptr; + m_video_buffer_read_ptr = nullptr; + m_video_buffer_seen_ptr = nullptr; + m_fifo_aux_write_ptr = nullptr; + m_fifo_aux_read_ptr = nullptr; - if (s_config_callback_id) + if (m_config_callback_id) { - Config::RemoveConfigChangedCallback(*s_config_callback_id); - s_config_callback_id = std::nullopt; + Config::RemoveConfigChangedCallback(*m_config_callback_id); + m_config_callback_id = std::nullopt; } } // May be executed from any thread, even the graphics thread. // Created to allow for self shutdown. -void ExitGpuLoop() +void FifoManager::ExitGpuLoop() { auto& system = Core::System::GetInstance(); auto& command_processor = system.GetCommandProcessor(); @@ -172,68 +131,68 @@ void ExitGpuLoop() FlushGpu(); // Terminate GPU thread loop - s_emu_running_state.Set(); - s_gpu_mainloop.Stop(s_gpu_mainloop.kNonBlock); + m_emu_running_state.Set(); + m_gpu_mainloop.Stop(m_gpu_mainloop.kNonBlock); } -void EmulatorState(bool running) +void FifoManager::EmulatorState(bool running) { - s_emu_running_state.Set(running); + m_emu_running_state.Set(running); if (running) - s_gpu_mainloop.Wakeup(); + m_gpu_mainloop.Wakeup(); else - s_gpu_mainloop.AllowSleep(); + m_gpu_mainloop.AllowSleep(); } -void SyncGPU(SyncGPUReason reason, bool may_move_read_ptr) +void FifoManager::SyncGPU(SyncGPUReason reason, bool may_move_read_ptr) { - if (s_use_deterministic_gpu_thread) + if (m_use_deterministic_gpu_thread) { - s_gpu_mainloop.Wait(); - if (!s_gpu_mainloop.IsRunning()) + m_gpu_mainloop.Wait(); + if (!m_gpu_mainloop.IsRunning()) return; // Opportunistically reset FIFOs so we don't wrap around. - if (may_move_read_ptr && s_fifo_aux_write_ptr != s_fifo_aux_read_ptr) + if (may_move_read_ptr && m_fifo_aux_write_ptr != m_fifo_aux_read_ptr) { - PanicAlertFmt("Aux FIFO not synced ({}, {})", fmt::ptr(s_fifo_aux_write_ptr), - fmt::ptr(s_fifo_aux_read_ptr)); + PanicAlertFmt("Aux FIFO not synced ({}, {})", fmt::ptr(m_fifo_aux_write_ptr), + fmt::ptr(m_fifo_aux_read_ptr)); } - memmove(s_fifo_aux_data, s_fifo_aux_read_ptr, s_fifo_aux_write_ptr - s_fifo_aux_read_ptr); - s_fifo_aux_write_ptr -= (s_fifo_aux_read_ptr - s_fifo_aux_data); - s_fifo_aux_read_ptr = s_fifo_aux_data; + memmove(m_fifo_aux_data, m_fifo_aux_read_ptr, m_fifo_aux_write_ptr - m_fifo_aux_read_ptr); + m_fifo_aux_write_ptr -= (m_fifo_aux_read_ptr - m_fifo_aux_data); + m_fifo_aux_read_ptr = m_fifo_aux_data; if (may_move_read_ptr) { - u8* write_ptr = s_video_buffer_write_ptr; + u8* write_ptr = m_video_buffer_write_ptr; // what's left over in the buffer - size_t size = write_ptr - s_video_buffer_pp_read_ptr; + size_t size = write_ptr - m_video_buffer_pp_read_ptr; - memmove(s_video_buffer, s_video_buffer_pp_read_ptr, size); + memmove(m_video_buffer, m_video_buffer_pp_read_ptr, size); // This change always decreases the pointers. We write seen_ptr // after write_ptr here, and read it before in RunGpuLoop, so // 'write_ptr > seen_ptr' there cannot become spuriously true. - s_video_buffer_write_ptr = write_ptr = s_video_buffer + size; - s_video_buffer_pp_read_ptr = s_video_buffer; - s_video_buffer_read_ptr = s_video_buffer; - s_video_buffer_seen_ptr = write_ptr; + m_video_buffer_write_ptr = write_ptr = m_video_buffer + size; + m_video_buffer_pp_read_ptr = m_video_buffer; + m_video_buffer_read_ptr = m_video_buffer; + m_video_buffer_seen_ptr = write_ptr; } } } -void PushFifoAuxBuffer(const void* ptr, size_t size) +void FifoManager::PushFifoAuxBuffer(const void* ptr, size_t size) { - if (size > (size_t)(s_fifo_aux_data + FIFO_SIZE - s_fifo_aux_write_ptr)) + if (size > (size_t)(m_fifo_aux_data + FIFO_SIZE - m_fifo_aux_write_ptr)) { SyncGPU(SyncGPUReason::AuxSpace, /* may_move_read_ptr */ false); - if (!s_gpu_mainloop.IsRunning()) + if (!m_gpu_mainloop.IsRunning()) { // GPU is shutting down return; } - if (size > (size_t)(s_fifo_aux_data + FIFO_SIZE - s_fifo_aux_write_ptr)) + if (size > (size_t)(m_fifo_aux_data + FIFO_SIZE - m_fifo_aux_write_ptr)) { // That will sync us up to the last 32 bytes, so this short region // of FIFO would have to point to a 2MB display list or something. @@ -241,63 +200,63 @@ void PushFifoAuxBuffer(const void* ptr, size_t size) return; } } - memcpy(s_fifo_aux_write_ptr, ptr, size); - s_fifo_aux_write_ptr += size; + memcpy(m_fifo_aux_write_ptr, ptr, size); + m_fifo_aux_write_ptr += size; } -void* PopFifoAuxBuffer(size_t size) +void* FifoManager::PopFifoAuxBuffer(size_t size) { - void* ret = s_fifo_aux_read_ptr; - s_fifo_aux_read_ptr += size; + void* ret = m_fifo_aux_read_ptr; + m_fifo_aux_read_ptr += size; return ret; } // Description: RunGpuLoop() sends data through this function. -static void ReadDataFromFifo(u32 readPtr) +void FifoManager::ReadDataFromFifo(u32 readPtr) { if (GPFifo::GATHER_PIPE_SIZE > - static_cast<size_t>(s_video_buffer + FIFO_SIZE - s_video_buffer_write_ptr)) + static_cast<size_t>(m_video_buffer + FIFO_SIZE - m_video_buffer_write_ptr)) { - const size_t existing_len = s_video_buffer_write_ptr - s_video_buffer_read_ptr; + const size_t existing_len = m_video_buffer_write_ptr - m_video_buffer_read_ptr; if (GPFifo::GATHER_PIPE_SIZE > static_cast<size_t>(FIFO_SIZE - existing_len)) { PanicAlertFmt("FIFO out of bounds (existing {} + new {} > {})", existing_len, GPFifo::GATHER_PIPE_SIZE, FIFO_SIZE); return; } - memmove(s_video_buffer, s_video_buffer_read_ptr, existing_len); - s_video_buffer_write_ptr = s_video_buffer + existing_len; - s_video_buffer_read_ptr = s_video_buffer; + memmove(m_video_buffer, m_video_buffer_read_ptr, existing_len); + m_video_buffer_write_ptr = m_video_buffer + existing_len; + m_video_buffer_read_ptr = m_video_buffer; } - // Copy new video instructions to s_video_buffer for future use in rendering the new picture + // Copy new video instructions to m_video_buffer for future use in rendering the new picture auto& system = Core::System::GetInstance(); auto& memory = system.GetMemory(); - memory.CopyFromEmu(s_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE); - s_video_buffer_write_ptr += GPFifo::GATHER_PIPE_SIZE; + memory.CopyFromEmu(m_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE); + m_video_buffer_write_ptr += GPFifo::GATHER_PIPE_SIZE; } // The deterministic_gpu_thread version. -static void ReadDataFromFifoOnCPU(u32 readPtr) +void FifoManager::ReadDataFromFifoOnCPU(u32 readPtr) { - u8* write_ptr = s_video_buffer_write_ptr; - if (GPFifo::GATHER_PIPE_SIZE > static_cast<size_t>(s_video_buffer + FIFO_SIZE - write_ptr)) + u8* write_ptr = m_video_buffer_write_ptr; + if (GPFifo::GATHER_PIPE_SIZE > static_cast<size_t>(m_video_buffer + FIFO_SIZE - write_ptr)) { // We can't wrap around while the GPU is working on the data. // This should be very rare due to the reset in SyncGPU. SyncGPU(SyncGPUReason::Wraparound); - if (!s_gpu_mainloop.IsRunning()) + if (!m_gpu_mainloop.IsRunning()) { // GPU is shutting down, so the next asserts may fail return; } - if (s_video_buffer_pp_read_ptr != s_video_buffer_read_ptr) + if (m_video_buffer_pp_read_ptr != m_video_buffer_read_ptr) { PanicAlertFmt("Desynced read pointers"); return; } - write_ptr = s_video_buffer_write_ptr; - const size_t existing_len = write_ptr - s_video_buffer_pp_read_ptr; + write_ptr = m_video_buffer_write_ptr; + const size_t existing_len = write_ptr - m_video_buffer_pp_read_ptr; if (GPFifo::GATHER_PIPE_SIZE > static_cast<size_t>(FIFO_SIZE - existing_len)) { PanicAlertFmt("FIFO out of bounds (existing {} + new {} > {})", existing_len, @@ -307,50 +266,50 @@ static void ReadDataFromFifoOnCPU(u32 readPtr) } auto& system = Core::System::GetInstance(); auto& memory = system.GetMemory(); - memory.CopyFromEmu(s_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE); - s_video_buffer_pp_read_ptr = OpcodeDecoder::RunFifo<true>( - DataReader(s_video_buffer_pp_read_ptr, write_ptr + GPFifo::GATHER_PIPE_SIZE), nullptr); + memory.CopyFromEmu(m_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE); + m_video_buffer_pp_read_ptr = OpcodeDecoder::RunFifo<true>( + DataReader(m_video_buffer_pp_read_ptr, write_ptr + GPFifo::GATHER_PIPE_SIZE), nullptr); // This would have to be locked if the GPU thread didn't spin. - s_video_buffer_write_ptr = write_ptr + GPFifo::GATHER_PIPE_SIZE; + m_video_buffer_write_ptr = write_ptr + GPFifo::GATHER_PIPE_SIZE; } -void ResetVideoBuffer() +void FifoManager::ResetVideoBuffer() { - s_video_buffer_read_ptr = s_video_buffer; - s_video_buffer_write_ptr = s_video_buffer; - s_video_buffer_seen_ptr = s_video_buffer; - s_video_buffer_pp_read_ptr = s_video_buffer; - s_fifo_aux_write_ptr = s_fifo_aux_data; - s_fifo_aux_read_ptr = s_fifo_aux_data; + m_video_buffer_read_ptr = m_video_buffer; + m_video_buffer_write_ptr = m_video_buffer; + m_video_buffer_seen_ptr = m_video_buffer; + m_video_buffer_pp_read_ptr = m_video_buffer; + m_fifo_aux_write_ptr = m_fifo_aux_data; + m_fifo_aux_read_ptr = m_fifo_aux_data; } // Description: Main FIFO update loop // Purpose: Keep the Core HW updated about the CPU-GPU distance -void RunGpuLoop() +void FifoManager::RunGpuLoop() { AsyncRequests::GetInstance()->SetEnable(true); AsyncRequests::GetInstance()->SetPassthrough(false); - s_gpu_mainloop.Run( - [] { + m_gpu_mainloop.Run( + [this] { // Run events from the CPU thread. AsyncRequests::GetInstance()->PullEvents(); // Do nothing while paused - if (!s_emu_running_state.IsSet()) + if (!m_emu_running_state.IsSet()) return; - if (s_use_deterministic_gpu_thread) + if (m_use_deterministic_gpu_thread) { // All the fifo/CP stuff is on the CPU. We just need to run the opcode decoder. - u8* seen_ptr = s_video_buffer_seen_ptr; - u8* write_ptr = s_video_buffer_write_ptr; + u8* seen_ptr = m_video_buffer_seen_ptr; + u8* write_ptr = m_video_buffer_write_ptr; // See comment in SyncGPU if (write_ptr > seen_ptr) { - s_video_buffer_read_ptr = - OpcodeDecoder::RunFifo(DataReader(s_video_buffer_read_ptr, write_ptr), nullptr); - s_video_buffer_seen_ptr = write_ptr; + m_video_buffer_read_ptr = + OpcodeDecoder::RunFifo(DataReader(m_video_buffer_read_ptr, write_ptr), nullptr); + m_video_buffer_seen_ptr = write_ptr; } } else @@ -365,7 +324,7 @@ void RunGpuLoop() fifo.bFF_GPReadEnable.load(std::memory_order_relaxed) && fifo.CPReadWriteDistance.load(std::memory_order_relaxed) && !AtBreakpoint()) { - if (s_config_sync_gpu && s_sync_ticks.load() < s_config_sync_gpu_min_distance) + if (m_config_sync_gpu && m_sync_ticks.load() < m_config_sync_gpu_min_distance) break; u32 cyclesExecuted = 0; @@ -385,13 +344,13 @@ void RunGpuLoop() "instability in the game. Please report it.", distance); - u8* write_ptr = s_video_buffer_write_ptr; - s_video_buffer_read_ptr = OpcodeDecoder::RunFifo( - DataReader(s_video_buffer_read_ptr, write_ptr), &cyclesExecuted); + u8* write_ptr = m_video_buffer_write_ptr; + m_video_buffer_read_ptr = OpcodeDecoder::RunFifo( + DataReader(m_video_buffer_read_ptr, write_ptr), &cyclesExecuted); fifo.CPReadPointer.store(readPtr, std::memory_order_relaxed); fifo.CPReadWriteDistance.fetch_sub(GPFifo::GATHER_PIPE_SIZE, std::memory_order_seq_cst); - if ((write_ptr - s_video_buffer_read_ptr) == 0) + if ((write_ptr - m_video_buffer_read_ptr) == 0) { fifo.SafeCPReadPointer.store(fifo.CPReadPointer.load(std::memory_order_relaxed), std::memory_order_relaxed); @@ -399,13 +358,15 @@ void RunGpuLoop() command_processor.SetCPStatusFromGPU(system); - if (s_config_sync_gpu) + if (m_config_sync_gpu) { - cyclesExecuted = (int)(cyclesExecuted / s_config_sync_gpu_overclock); - int old = s_sync_ticks.fetch_sub(cyclesExecuted); - if (old >= s_config_sync_gpu_max_distance && - old - (int)cyclesExecuted < s_config_sync_gpu_max_distance) - s_sync_wakeup_event.Set(); + cyclesExecuted = (int)(cyclesExecuted / m_config_sync_gpu_overclock); + int old = m_sync_ticks.fetch_sub(cyclesExecuted); + if (old >= m_config_sync_gpu_max_distance && + old - (int)cyclesExecuted < m_config_sync_gpu_max_distance) + { + m_sync_wakeup_event.Set(); + } } // This call is pretty important in DualCore mode and must be called in the FIFO Loop. @@ -416,11 +377,11 @@ void RunGpuLoop() } // fast skip remaining GPU time if fifo is empty - if (s_sync_ticks.load() > 0) + if (m_sync_ticks.load() > 0) { - int old = s_sync_ticks.exchange(0); - if (old >= s_config_sync_gpu_max_distance) - s_sync_wakeup_event.Set(); + int old = m_sync_ticks.exchange(0); + if (old >= m_config_sync_gpu_max_distance) + m_sync_wakeup_event.Set(); } // The fifo is empty and it's unlikely we will get any more work in the near future. @@ -435,20 +396,20 @@ void RunGpuLoop() AsyncRequests::GetInstance()->SetPassthrough(true); } -void FlushGpu() +void FifoManager::FlushGpu() { - if (!Core::System::GetInstance().IsDualCoreMode() || s_use_deterministic_gpu_thread) + if (!Core::System::GetInstance().IsDualCoreMode() || m_use_deterministic_gpu_thread) return; - s_gpu_mainloop.Wait(); + m_gpu_mainloop.Wait(); } -void GpuMaySleep() +void FifoManager::GpuMaySleep() { - s_gpu_mainloop.AllowSleep(); + m_gpu_mainloop.AllowSleep(); } -bool AtBreakpoint() +bool FifoManager::AtBreakpoint() const { auto& system = Core::System::GetInstance(); auto& command_processor = system.GetCommandProcessor(); @@ -458,44 +419,44 @@ bool AtBreakpoint() fifo.CPBreakpoint.load(std::memory_order_relaxed)); } -void RunGpu() +void FifoManager::RunGpu() { auto& system = Core::System::GetInstance(); const bool is_dual_core = system.IsDualCoreMode(); // wake up GPU thread - if (is_dual_core && !s_use_deterministic_gpu_thread) + if (is_dual_core && !m_use_deterministic_gpu_thread) { - s_gpu_mainloop.Wakeup(); + m_gpu_mainloop.Wakeup(); } // if the sync GPU callback is suspended, wake it up. - if (!is_dual_core || s_use_deterministic_gpu_thread || s_config_sync_gpu) + if (!is_dual_core || m_use_deterministic_gpu_thread || m_config_sync_gpu) { - if (s_syncing_suspended) + if (m_syncing_suspended) { - s_syncing_suspended = false; - system.GetCoreTiming().ScheduleEvent(GPU_TIME_SLOT_SIZE, s_event_sync_gpu, + m_syncing_suspended = false; + system.GetCoreTiming().ScheduleEvent(GPU_TIME_SLOT_SIZE, m_event_sync_gpu, GPU_TIME_SLOT_SIZE); } } } -static int RunGpuOnCpu(int ticks) +int FifoManager::RunGpuOnCpu(int ticks) { auto& system = Core::System::GetInstance(); auto& command_processor = system.GetCommandProcessor(); auto& fifo = command_processor.GetFifo(); bool reset_simd_state = false; - int available_ticks = int(ticks * s_config_sync_gpu_overclock) + s_sync_ticks.load(); + int available_ticks = int(ticks * m_config_sync_gpu_overclock) + m_sync_ticks.load(); while (fifo.bFF_GPReadEnable.load(std::memory_order_relaxed) && fifo.CPReadWriteDistance.load(std::memory_order_relaxed) && !AtBreakpoint() && available_ticks >= 0) { - if (s_use_deterministic_gpu_thread) + if (m_use_deterministic_gpu_thread) { ReadDataFromFifoOnCPU(fifo.CPReadPointer.load(std::memory_order_relaxed)); - s_gpu_mainloop.Wakeup(); + m_gpu_mainloop.Wakeup(); } else { @@ -507,8 +468,8 @@ static int RunGpuOnCpu(int ticks) } ReadDataFromFifo(fifo.CPReadPointer.load(std::memory_order_relaxed)); u32 cycles = 0; - s_video_buffer_read_ptr = OpcodeDecoder::RunFifo( - DataReader(s_video_buffer_read_ptr, s_video_buffer_write_ptr), &cycles); + m_video_buffer_read_ptr = OpcodeDecoder::RunFifo( + DataReader(m_video_buffer_read_ptr, m_video_buffer_write_ptr), &cycles); available_ticks -= cycles; } @@ -534,7 +495,7 @@ static int RunGpuOnCpu(int ticks) } // Discard all available ticks as there is nothing to do any more. - s_sync_ticks.store(std::min(available_ticks, 0)); + m_sync_ticks.store(std::min(available_ticks, 0)); // If the GPU is idle, drop the handler. if (available_ticks >= 0) @@ -544,7 +505,7 @@ static int RunGpuOnCpu(int ticks) return -available_ticks + GPU_TIME_SLOT_SIZE; } -void UpdateWantDeterminism(bool want) +void FifoManager::UpdateWantDeterminism(bool want) { // We are paused (or not running at all yet), so // it should be safe to change this. @@ -564,87 +525,83 @@ void UpdateWantDeterminism(bool want) gpu_thread = gpu_thread && Core::System::GetInstance().IsDualCoreMode(); - if (s_use_deterministic_gpu_thread != gpu_thread) + if (m_use_deterministic_gpu_thread != gpu_thread) { - s_use_deterministic_gpu_thread = gpu_thread; + m_use_deterministic_gpu_thread = gpu_thread; if (gpu_thread) { // These haven't been updated in non-deterministic mode. - s_video_buffer_seen_ptr = s_video_buffer_pp_read_ptr = s_video_buffer_read_ptr; + m_video_buffer_seen_ptr = m_video_buffer_pp_read_ptr = m_video_buffer_read_ptr; CopyPreprocessCPStateFromMain(); VertexLoaderManager::MarkAllDirty(); } } } -bool UseDeterministicGPUThread() -{ - return s_use_deterministic_gpu_thread; -} - /* This function checks the emulated CPU - GPU distance and may wake up the GPU, * or block the CPU if required. It should be called by the CPU thread regularly. * @ticks The gone emulated CPU time. * @return A good time to call WaitForGpuThread() next. */ -static int WaitForGpuThread(int ticks) +int FifoManager::WaitForGpuThread(int ticks) { - int old = s_sync_ticks.fetch_add(ticks); + int old = m_sync_ticks.fetch_add(ticks); int now = old + ticks; // GPU is idle, so stop polling. - if (old >= 0 && s_gpu_mainloop.IsDone()) + if (old >= 0 && m_gpu_mainloop.IsDone()) return -1; // Wakeup GPU - if (old < s_config_sync_gpu_min_distance && now >= s_config_sync_gpu_min_distance) + if (old < m_config_sync_gpu_min_distance && now >= m_config_sync_gpu_min_distance) RunGpu(); // If the GPU is still sleeping, wait for a longer time - if (now < s_config_sync_gpu_min_distance) - return GPU_TIME_SLOT_SIZE + s_config_sync_gpu_min_distance - now; + if (now < m_config_sync_gpu_min_distance) + return GPU_TIME_SLOT_SIZE + m_config_sync_gpu_min_distance - now; // Wait for GPU - if (now >= s_config_sync_gpu_max_distance) - s_sync_wakeup_event.Wait(); + if (now >= m_config_sync_gpu_max_distance) + m_sync_wakeup_event.Wait(); return GPU_TIME_SLOT_SIZE; } -static void SyncGPUCallback(Core::System& system, u64 ticks, s64 cyclesLate) +void FifoManager::SyncGPUCallback(Core::System& system, u64 ticks, s64 cyclesLate) { ticks += cyclesLate; int next = -1; - if (!system.IsDualCoreMode() || s_use_deterministic_gpu_thread) + auto& fifo = system.GetFifo(); + if (!system.IsDualCoreMode() || fifo.m_use_deterministic_gpu_thread) { - next = RunGpuOnCpu((int)ticks); + next = fifo.RunGpuOnCpu((int)ticks); } - else if (s_config_sync_gpu) + else if (fifo.m_config_sync_gpu) { - next = WaitForGpuThread((int)ticks); + next = fifo.WaitForGpuThread((int)ticks); } - s_syncing_suspended = next < 0; - if (!s_syncing_suspended) - system.GetCoreTiming().ScheduleEvent(next, s_event_sync_gpu, next); + fifo.m_syncing_suspended = next < 0; + if (!fifo.m_syncing_suspended) + system.GetCoreTiming().ScheduleEvent(next, fifo.m_event_sync_gpu, next); } -void SyncGPUForRegisterAccess() +void FifoManager::SyncGPUForRegisterAccess() { SyncGPU(SyncGPUReason::Other); - if (!Core::System::GetInstance().IsDualCoreMode() || s_use_deterministic_gpu_thread) + if (!Core::System::GetInstance().IsDualCoreMode() || m_use_deterministic_gpu_thread) RunGpuOnCpu(GPU_TIME_SLOT_SIZE); - else if (s_config_sync_gpu) + else if (m_config_sync_gpu) WaitForGpuThread(GPU_TIME_SLOT_SIZE); } // Initialize GPU - CPU thread syncing, this gives us a deterministic way to start the GPU thread. -void Prepare() +void FifoManager::Prepare() { - s_event_sync_gpu = + m_event_sync_gpu = Core::System::GetInstance().GetCoreTiming().RegisterEvent("SyncGPUCallback", SyncGPUCallback); - s_syncing_suspended = true; + m_syncing_suspended = true; } } // namespace Fifo |