2022-04-23 11:59:50 +03:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2019-01-24 06:17:55 +03:00
|
|
|
|
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/microprofile.h"
|
2020-12-25 10:28:46 +03:00
|
|
|
#include "common/scope_exit.h"
|
2021-04-15 02:07:40 +03:00
|
|
|
#include "common/settings.h"
|
2020-02-25 18:12:46 +03:00
|
|
|
#include "common/thread.h"
|
2019-03-31 03:08:09 +03:00
|
|
|
#include "core/core.h"
|
2020-03-25 05:58:49 +03:00
|
|
|
#include "core/frontend/emu_window.h"
|
2019-01-24 06:17:55 +03:00
|
|
|
#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
|
2021-09-16 03:32:54 +03:00
|
|
|
static void RunThread(std::stop_token stop_token, Core::System& system,
|
|
|
|
VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context,
|
|
|
|
Tegra::DmaPusher& dma_pusher, SynchState& state) {
|
2020-02-25 18:12:46 +03:00
|
|
|
std::string name = "yuzu:GPU";
|
|
|
|
MicroProfileOnThreadCreate(name.c_str());
|
2020-12-25 10:28:46 +03:00
|
|
|
SCOPE_EXIT({ MicroProfileOnThreadExit(); });
|
|
|
|
|
2020-02-25 18:12:46 +03:00
|
|
|
Common::SetCurrentThreadName(name.c_str());
|
2020-04-05 16:48:53 +03:00
|
|
|
Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
|
2020-02-25 18:12:46 +03:00
|
|
|
system.RegisterHostThread();
|
2019-01-24 06:17:55 +03:00
|
|
|
|
2020-03-25 05:58:49 +03:00
|
|
|
auto current_context = context.Acquire();
|
2021-01-05 10:09:39 +03:00
|
|
|
VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
|
2019-01-24 06:17:55 +03:00
|
|
|
|
2021-09-16 03:32:54 +03:00
|
|
|
while (!stop_token.stop_requested()) {
|
2022-07-06 08:33:17 +03:00
|
|
|
CommandDataContainer next = state.queue.PopWait(stop_token);
|
2021-09-16 03:32:54 +03:00
|
|
|
if (stop_token.stop_requested()) {
|
|
|
|
break;
|
|
|
|
}
|
2020-12-04 22:39:12 +03:00
|
|
|
if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
|
2019-11-23 23:17:28 +03:00
|
|
|
dma_pusher.Push(std::move(submit_list->entries));
|
|
|
|
dma_pusher.DispatchCalls();
|
2021-01-07 23:56:15 +03:00
|
|
|
} else if (const auto* data = std::get_if<SwapBuffersCommand>(&next.data)) {
|
2019-11-23 23:17:28 +03:00
|
|
|
renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
|
2020-07-21 07:52:27 +03:00
|
|
|
} else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer->ReleaseFences();
|
2020-07-21 07:52:27 +03:00
|
|
|
} else if (std::holds_alternative<GPUTickCommand>(next.data)) {
|
2020-02-20 18:55:32 +03:00
|
|
|
system.GPU().TickWork();
|
2020-12-04 22:39:12 +03:00
|
|
|
} else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer->FlushRegion(flush->addr, flush->size);
|
2020-12-04 22:39:12 +03:00
|
|
|
} else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer->OnCPUWrite(invalidate->addr, invalidate->size);
|
2019-11-23 23:17:28 +03:00
|
|
|
} else {
|
2022-06-08 00:02:29 +03:00
|
|
|
ASSERT(false);
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
2019-11-23 23:17:28 +03:00
|
|
|
state.signaled_fence.store(next.fence);
|
2021-04-07 12:41:31 +03:00
|
|
|
if (next.block) {
|
|
|
|
// We have to lock the write_lock to ensure that the condition_variable wait not get a
|
|
|
|
// race between the check and the lock itself.
|
2022-04-07 21:32:40 +03:00
|
|
|
std::scoped_lock lk{state.write_lock};
|
2021-04-07 12:41:31 +03:00
|
|
|
state.cv.notify_all();
|
|
|
|
}
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-12 11:24:33 +03:00
|
|
|
ThreadManager::ThreadManager(Core::System& system_, bool is_async_)
|
|
|
|
: system{system_}, is_async{is_async_} {}
|
2019-01-24 06:17:55 +03:00
|
|
|
|
2021-09-16 03:32:54 +03:00
|
|
|
ThreadManager::~ThreadManager() = default;
|
2019-01-24 06:17:55 +03:00
|
|
|
|
2020-03-25 05:58:49 +03:00
|
|
|
void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
|
|
|
|
Core::Frontend::GraphicsContext& context,
|
2021-03-01 06:03:00 +03:00
|
|
|
Tegra::DmaPusher& dma_pusher) {
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer = renderer.ReadRasterizer();
|
2021-09-16 03:32:54 +03:00
|
|
|
thread = std::jthread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
|
|
|
|
std::ref(dma_pusher), std::ref(state));
|
2019-04-09 21:02:00 +03:00
|
|
|
}
|
|
|
|
|
2019-01-24 06:17:55 +03:00
|
|
|
void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
|
2019-09-26 02:43:23 +03:00
|
|
|
PushCommand(SubmitListCommand(std::move(entries)));
|
2020-10-27 06:07:36 +03:00
|
|
|
}
|
|
|
|
|
2019-08-21 07:55:25 +03:00
|
|
|
void ThreadManager::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
|
2019-11-28 01:46:07 +03:00
|
|
|
PushCommand(SwapBuffersCommand(framebuffer ? std::make_optional(*framebuffer) : std::nullopt));
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
|
|
|
|
2020-04-05 19:58:23 +03:00
|
|
|
void ThreadManager::FlushRegion(VAddr addr, u64 size) {
|
2020-12-12 11:24:33 +03:00
|
|
|
if (!is_async) {
|
|
|
|
// Always flush with synchronous GPU mode
|
2020-04-19 20:47:45 +03:00
|
|
|
PushCommand(FlushRegionCommand(addr, size));
|
|
|
|
return;
|
|
|
|
}
|
2021-06-07 03:04:35 +03:00
|
|
|
if (!Settings::IsGPULevelExtreme()) {
|
|
|
|
return;
|
2020-02-18 05:29:04 +03:00
|
|
|
}
|
2021-06-07 03:04:35 +03:00
|
|
|
auto& gpu = system.GPU();
|
|
|
|
u64 fence = gpu.RequestFlush(addr, size);
|
|
|
|
PushCommand(GPUTickCommand(), true);
|
|
|
|
ASSERT(fence <= gpu.CurrentFlushRequestFence());
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
|
|
|
|
2020-04-05 19:58:23 +03:00
|
|
|
void ThreadManager::InvalidateRegion(VAddr addr, u64 size) {
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer->OnCPUWrite(addr, size);
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
|
|
|
|
2020-04-05 19:58:23 +03:00
|
|
|
void ThreadManager::FlushAndInvalidateRegion(VAddr addr, u64 size) {
|
2019-02-19 04:58:32 +03:00
|
|
|
// Skip flush on asynch mode, as FlushAndInvalidateRegion is not used for anything too important
|
2021-01-05 10:09:39 +03:00
|
|
|
rasterizer->OnCPUWrite(addr, size);
|
2019-01-24 06:17:55 +03:00
|
|
|
}
|
|
|
|
|
2020-02-18 01:10:23 +03:00
|
|
|
void ThreadManager::OnCommandListEnd() {
|
|
|
|
PushCommand(OnCommandListEndCommand());
|
|
|
|
}
|
|
|
|
|
2021-04-07 12:41:31 +03:00
|
|
|
u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
|
|
|
|
if (!is_async) {
|
|
|
|
// In synchronous GPU mode, block the caller until the command has executed
|
|
|
|
block = true;
|
|
|
|
}
|
|
|
|
|
2021-04-07 14:57:49 +03:00
|
|
|
std::unique_lock lk(state.write_lock);
|
2019-03-31 03:08:09 +03:00
|
|
|
const u64 fence{++state.last_fence};
|
2021-04-07 12:41:31 +03:00
|
|
|
state.queue.Push(CommandDataContainer(std::move(command_data), fence, block));
|
2020-12-12 11:24:33 +03:00
|
|
|
|
2021-04-07 12:41:31 +03:00
|
|
|
if (block) {
|
2021-09-16 03:32:54 +03:00
|
|
|
state.cv.wait(lk, thread.get_stop_token(), [this, fence] {
|
|
|
|
return fence <= state.signaled_fence.load(std::memory_order_relaxed);
|
2021-04-07 12:41:31 +03:00
|
|
|
});
|
2020-12-12 11:24:33 +03:00
|
|
|
}
|
|
|
|
|
2019-03-31 03:08:09 +03:00
|
|
|
return fence;
|
|
|
|
}
|
|
|
|
|
2019-01-24 06:17:55 +03:00
|
|
|
} // namespace VideoCommon::GPUThread
|