pineapple-src/src/video_core/gpu_thread.h

148 lines
4.3 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.
#pragma once
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <thread>
#include <variant>
2020-12-30 01:38:14 +00:00
2021-10-27 03:22:08 +00:00
#include "common/threadsafe_queue.h"
2020-12-30 01:38:14 +00:00
#include "video_core/framebuffer_config.h"
2020-12-28 15:15:37 +00:00
namespace Tegra {
struct FramebufferConfig;
class DmaPusher;
} // namespace Tegra
namespace Core {
namespace Frontend {
class GraphicsContext;
}
class System;
} // namespace Core
2020-12-30 01:38:14 +00:00
namespace VideoCore {
2021-01-17 02:19:34 +00:00
class RasterizerInterface;
2020-12-30 01:38:14 +00:00
class RendererBase;
} // namespace VideoCore
2020-12-28 15:15:37 +00:00
namespace VideoCommon::GPUThread {
/// Command to signal to the GPU thread that a command list is ready for processing
struct SubmitListCommand final {
explicit SubmitListCommand(Tegra::CommandList&& entries_) : entries{std::move(entries_)} {}
Tegra::CommandList entries;
};
/// Command to signal to the GPU thread that a swap buffers is pending
struct SwapBuffersCommand final {
explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer_)
: framebuffer{std::move(framebuffer_)} {}
std::optional<Tegra::FramebufferConfig> framebuffer;
};
/// Command to signal to the GPU thread to flush a region
struct FlushRegionCommand final {
explicit constexpr FlushRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}
VAddr addr;
u64 size;
};
/// Command to signal to the GPU thread to invalidate a region
struct InvalidateRegionCommand final {
explicit constexpr InvalidateRegionCommand(VAddr addr_, u64 size_) : addr{addr_}, size{size_} {}
VAddr addr;
u64 size;
};
/// Command to signal to the GPU thread to flush and invalidate a region
struct FlushAndInvalidateRegionCommand final {
explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr_, u64 size_)
: addr{addr_}, size{size_} {}
VAddr addr;
u64 size;
};
/// Command called within the gpu, to schedule actions after a command list end
struct OnCommandListEndCommand final {};
/// Command to make the gpu look into pending requests
struct GPUTickCommand final {};
using CommandData =
2021-09-16 04:04:40 +00:00
std::variant<std::monostate, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
2021-03-01 10:12:51 +00:00
InvalidateRegionCommand, FlushAndInvalidateRegionCommand, OnCommandListEndCommand,
GPUTickCommand>;
2020-12-28 15:15:37 +00:00
struct CommandDataContainer {
CommandDataContainer() = default;
2021-04-07 18:28:12 +00:00
explicit CommandDataContainer(CommandData&& data_, u64 next_fence_, bool block_)
: data{std::move(data_)}, fence{next_fence_}, block(block_) {}
2020-12-28 15:15:37 +00:00
CommandData data;
u64 fence{};
2021-04-07 18:28:12 +00:00
bool block{};
2020-12-28 15:15:37 +00:00
};
/// Struct used to synchronize the GPU thread
struct SynchState final {
2021-10-27 03:22:08 +00:00
using CommandQueue = Common::SPSCQueue<CommandDataContainer, true>;
2021-04-07 18:28:12 +00:00
std::mutex write_lock;
2021-10-27 03:22:08 +00:00
CommandQueue queue;
2020-12-28 15:15:37 +00:00
u64 last_fence{};
std::atomic<u64> signaled_fence{};
2021-09-16 04:04:40 +00:00
std::condition_variable_any cv;
2020-12-28 15:15:37 +00:00
};
/// Class used to manage the GPU thread
class ThreadManager final {
public:
2020-12-30 01:38:14 +00:00
explicit ThreadManager(Core::System& system_, bool is_async_);
2020-12-28 15:15:37 +00:00
~ThreadManager();
/// Creates and starts the GPU thread.
void StartThread(VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context,
2021-03-01 10:12:51 +00:00
Tegra::DmaPusher& dma_pusher);
2020-12-28 15:15:37 +00:00
/// Push GPU command entries to be processed
void SubmitList(Tegra::CommandList&& entries);
/// Swap buffers (render frame)
void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
void FlushRegion(VAddr addr, u64 size);
/// Notify rasterizer that any caches of the specified region should be invalidated
void InvalidateRegion(VAddr addr, u64 size);
/// Notify rasterizer that any caches of the specified region should be flushed and invalidated
void FlushAndInvalidateRegion(VAddr addr, u64 size);
void OnCommandListEnd();
private:
/// Pushes a command to be executed by the GPU thread
2021-04-07 18:28:12 +00:00
u64 PushCommand(CommandData&& command_data, bool block = false);
2020-12-28 15:15:37 +00:00
Core::System& system;
2020-12-30 01:38:14 +00:00
const bool is_async;
2021-01-17 02:19:34 +00:00
VideoCore::RasterizerInterface* rasterizer = nullptr;
SynchState state;
2021-09-16 04:04:40 +00:00
std::jthread thread;
2020-12-28 15:15:37 +00:00
};
} // namespace VideoCommon::GPUThread