pineapple-src/src/video_core/gpu_thread.cpp

165 lines
5.8 KiB
C++
Raw Normal View History

2020-12-28 15:15:37 +00:00
// Copyright 2019 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "common/assert.h"
#include "common/microprofile.h"
2020-12-30 01:38:14 +00:00
#include "common/scope_exit.h"
2020-12-28 15:15:37 +00:00
#include "common/thread.h"
#include "core/core.h"
#include "core/frontend/emu_window.h"
#include "core/settings.h"
#include "video_core/dma_pusher.h"
#include "video_core/gpu.h"
#include "video_core/gpu_thread.h"
#include "video_core/renderer_base.h"
namespace VideoCommon::GPUThread {
/// Runs the GPU thread
static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
Core::Frontend::GraphicsContext& context, Tegra::DmaPusher& dma_pusher,
SynchState& state, Tegra::CDmaPusher& cdma_pusher) {
std::string name = "yuzu:GPU";
MicroProfileOnThreadCreate(name.c_str());
2020-12-30 01:38:14 +00:00
SCOPE_EXIT({ MicroProfileOnThreadExit(); });
2020-12-28 15:15:37 +00:00
Common::SetCurrentThreadName(name.c_str());
Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
system.RegisterHostThread();
// Wait for first GPU command before acquiring the window context
while (state.queue.Empty())
;
// If emulation was stopped during disk shader loading, abort before trying to acquire context
if (!state.is_running) {
return;
}
auto current_context = context.Acquire();
2021-01-17 02:19:34 +00:00
VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
2020-12-28 15:15:37 +00:00
CommandDataContainer next;
while (state.is_running) {
next = state.queue.PopWait();
if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
dma_pusher.Push(std::move(submit_list->entries));
dma_pusher.DispatchCalls();
} else if (auto* command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
// NVDEC
2021-01-15 20:03:50 +00:00
cdma_pusher.Push(std::move(command_list->entries));
cdma_pusher.DispatchCalls();
2020-12-28 15:15:37 +00:00
} else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
} else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
2021-01-17 02:19:34 +00:00
rasterizer->ReleaseFences();
2020-12-28 15:15:37 +00:00
} else if (std::holds_alternative<GPUTickCommand>(next.data)) {
system.GPU().TickWork();
} else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
2021-01-17 02:19:34 +00:00
rasterizer->FlushRegion(flush->addr, flush->size);
2020-12-28 15:15:37 +00:00
} else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
2021-01-17 02:19:34 +00:00
rasterizer->OnCPUWrite(invalidate->addr, invalidate->size);
2020-12-28 15:15:37 +00:00
} else if (std::holds_alternative<EndProcessingCommand>(next.data)) {
return;
} else {
UNREACHABLE();
}
state.signaled_fence.store(next.fence);
}
}
2020-12-30 01:38:14 +00:00
ThreadManager::ThreadManager(Core::System& system_, bool is_async_)
: system{system_}, is_async{is_async_} {}
2020-12-28 15:15:37 +00:00
ThreadManager::~ThreadManager() {
if (!thread.joinable()) {
return;
}
// Notify GPU thread that a shutdown is pending
PushCommand(EndProcessingCommand());
thread.join();
}
void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
Core::Frontend::GraphicsContext& context,
Tegra::DmaPusher& dma_pusher, Tegra::CDmaPusher& cdma_pusher) {
2021-01-17 02:19:34 +00:00
rasterizer = renderer.ReadRasterizer();
2020-12-28 15:15:37 +00:00
thread = std::thread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
std::ref(dma_pusher), std::ref(state), std::ref(cdma_pusher));
}
void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
PushCommand(SubmitListCommand(std::move(entries)));
}
void ThreadManager::SubmitCommandBuffer(Tegra::ChCommandHeaderList&& entries) {
PushCommand(SubmitChCommandEntries(std::move(entries)));
}
void ThreadManager::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
PushCommand(SwapBuffersCommand(framebuffer ? std::make_optional(*framebuffer) : std::nullopt));
}
void ThreadManager::FlushRegion(VAddr addr, u64 size) {
2020-12-30 01:38:14 +00:00
if (!is_async) {
// Always flush with synchronous GPU mode
2020-12-28 15:15:37 +00:00
PushCommand(FlushRegionCommand(addr, size));
return;
}
2020-12-30 01:38:14 +00:00
// Asynchronous GPU mode
switch (Settings::values.gpu_accuracy.GetValue()) {
case Settings::GPUAccuracy::Normal:
PushCommand(FlushRegionCommand(addr, size));
break;
case Settings::GPUAccuracy::High:
// TODO(bunnei): Is this right? Preserving existing behavior for now
break;
case Settings::GPUAccuracy::Extreme: {
2020-12-28 15:15:37 +00:00
auto& gpu = system.GPU();
u64 fence = gpu.RequestFlush(addr, size);
PushCommand(GPUTickCommand());
while (fence > gpu.CurrentFlushRequestFence()) {
}
2020-12-30 01:38:14 +00:00
break;
}
default:
UNIMPLEMENTED_MSG("Unsupported gpu_accuracy {}", Settings::values.gpu_accuracy.GetValue());
2020-12-28 15:15:37 +00:00
}
}
void ThreadManager::InvalidateRegion(VAddr addr, u64 size) {
2021-01-17 02:19:34 +00:00
rasterizer->OnCPUWrite(addr, size);
2020-12-28 15:15:37 +00:00
}
void ThreadManager::FlushAndInvalidateRegion(VAddr addr, u64 size) {
// Skip flush on asynch mode, as FlushAndInvalidateRegion is not used for anything too important
2021-01-17 02:19:34 +00:00
rasterizer->OnCPUWrite(addr, size);
2020-12-28 15:15:37 +00:00
}
void ThreadManager::WaitIdle() const {
2020-12-30 01:38:14 +00:00
while (state.last_fence > state.signaled_fence.load(std::memory_order_relaxed) &&
system.IsPoweredOn()) {
2020-12-28 15:15:37 +00:00
}
}
void ThreadManager::OnCommandListEnd() {
PushCommand(OnCommandListEndCommand());
}
u64 ThreadManager::PushCommand(CommandData&& command_data) {
const u64 fence{++state.last_fence};
state.queue.Push(CommandDataContainer(std::move(command_data), fence));
2020-12-30 01:38:14 +00:00
if (!is_async) {
// In synchronous GPU mode, block the caller until the command has executed
WaitIdle();
}
2020-12-28 15:15:37 +00:00
return fence;
}
} // namespace VideoCommon::GPUThread