2024-03-06 06:26:38 +01:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
2022-04-23 10:59:50 +02:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2018-03-18 21:15:05 +01:00
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
#include <array>
|
|
|
|
#include <atomic>
|
2020-02-25 03:04:12 +01:00
|
|
|
#include <chrono>
|
2021-10-01 06:57:02 +02:00
|
|
|
#include <condition_variable>
|
|
|
|
#include <list>
|
|
|
|
#include <memory>
|
2020-02-25 03:04:12 +01:00
|
|
|
|
2018-08-11 00:39:37 +02:00
|
|
|
#include "common/assert.h"
|
2019-09-26 01:43:23 +02:00
|
|
|
#include "common/microprofile.h"
|
2021-04-15 01:07:40 +02:00
|
|
|
#include "common/settings.h"
|
2019-02-14 18:42:58 +01:00
|
|
|
#include "core/core.h"
|
2019-01-30 03:49:18 +01:00
|
|
|
#include "core/core_timing.h"
|
2020-03-25 03:58:49 +01:00
|
|
|
#include "core/frontend/emu_window.h"
|
2023-02-19 08:31:39 +01:00
|
|
|
#include "core/frontend/graphics_context.h"
|
2021-10-01 06:57:02 +02:00
|
|
|
#include "core/hle/service/nvdrv/nvdata.h"
|
2021-05-16 02:34:20 +02:00
|
|
|
#include "core/perf_stats.h"
|
2021-10-01 06:57:02 +02:00
|
|
|
#include "video_core/cdma_pusher.h"
|
2021-11-05 15:52:31 +01:00
|
|
|
#include "video_core/control/channel_state.h"
|
|
|
|
#include "video_core/control/scheduler.h"
|
2021-10-01 06:57:02 +02:00
|
|
|
#include "video_core/dma_pusher.h"
|
2018-03-18 21:15:05 +01:00
|
|
|
#include "video_core/engines/fermi_2d.h"
|
2019-01-23 00:49:31 +01:00
|
|
|
#include "video_core/engines/kepler_compute.h"
|
2018-09-08 22:58:20 +02:00
|
|
|
#include "video_core/engines/kepler_memory.h"
|
2018-03-18 21:15:05 +01:00
|
|
|
#include "video_core/engines/maxwell_3d.h"
|
2018-06-11 00:02:33 +02:00
|
|
|
#include "video_core/engines/maxwell_dma.h"
|
2018-03-18 21:15:05 +01:00
|
|
|
#include "video_core/gpu.h"
|
2021-10-01 06:57:02 +02:00
|
|
|
#include "video_core/gpu_thread.h"
|
2022-01-30 10:31:13 +01:00
|
|
|
#include "video_core/host1x/host1x.h"
|
|
|
|
#include "video_core/host1x/syncpoint_manager.h"
|
2019-03-04 05:54:16 +01:00
|
|
|
#include "video_core/memory_manager.h"
|
2019-01-08 05:32:02 +01:00
|
|
|
#include "video_core/renderer_base.h"
|
2020-07-10 05:36:38 +02:00
|
|
|
#include "video_core/shader_notify.h"
|
2018-03-18 21:15:05 +01:00
|
|
|
|
|
|
|
namespace Tegra {
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
struct GPU::Impl {
|
|
|
|
explicit Impl(GPU& gpu_, Core::System& system_, bool is_async_, bool use_nvdec_)
|
2022-01-30 10:31:13 +01:00
|
|
|
: gpu{gpu_}, system{system_}, host1x{system.Host1x()}, use_nvdec{use_nvdec_},
|
2021-10-01 06:57:02 +02:00
|
|
|
shader_notify{std::make_unique<VideoCore::ShaderNotify>()}, is_async{is_async_},
|
2021-11-05 15:52:31 +01:00
|
|
|
gpu_thread{system_, is_async_}, scheduler{std::make_unique<Control::Scheduler>(gpu)} {}
|
2021-10-01 06:57:02 +02:00
|
|
|
|
|
|
|
~Impl() = default;
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
std::shared_ptr<Control::ChannelState> CreateChannel(s32 channel_id) {
|
|
|
|
auto channel_state = std::make_shared<Tegra::Control::ChannelState>(channel_id);
|
|
|
|
channels.emplace(channel_id, channel_state);
|
|
|
|
scheduler->DeclareChannel(channel_state);
|
|
|
|
return channel_state;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void BindChannel(s32 channel_id) {
|
|
|
|
if (bound_channel == channel_id) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto it = channels.find(channel_id);
|
|
|
|
ASSERT(it != channels.end());
|
|
|
|
bound_channel = channel_id;
|
|
|
|
current_channel = it->second.get();
|
2021-10-01 06:57:02 +02:00
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
rasterizer->BindChannel(*current_channel);
|
|
|
|
}
|
2021-10-01 06:57:02 +02:00
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
std::shared_ptr<Control::ChannelState> AllocateChannel() {
|
|
|
|
return CreateChannel(new_channel_id++);
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
2024-02-24 04:38:21 +01:00
|
|
|
void InitChannel(Control::ChannelState& to_init, u64 program_id) {
|
|
|
|
to_init.Init(system, gpu, program_id);
|
2021-11-05 15:52:31 +01:00
|
|
|
to_init.BindRasterizer(rasterizer);
|
|
|
|
rasterizer->InitializeChannel(to_init);
|
|
|
|
}
|
2021-10-01 06:57:02 +02:00
|
|
|
|
2022-01-01 22:03:37 +01:00
|
|
|
void InitAddressSpace(Tegra::MemoryManager& memory_manager) {
|
|
|
|
memory_manager.BindRasterizer(rasterizer);
|
|
|
|
}
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void ReleaseChannel(Control::ChannelState& to_release) {
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
}
|
2021-10-01 06:57:02 +02:00
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
/// Binds a renderer to the GPU.
|
|
|
|
void BindRenderer(std::unique_ptr<VideoCore::RendererBase> renderer_) {
|
|
|
|
renderer = std::move(renderer_);
|
|
|
|
rasterizer = renderer->ReadRasterizer();
|
2023-12-24 18:20:02 +01:00
|
|
|
host1x.MemoryManager().BindInterface(rasterizer);
|
2023-12-29 09:50:04 +01:00
|
|
|
host1x.GMMU().BindRasterizer(rasterizer);
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Flush all current written commands into the host GPU for execution.
|
|
|
|
void FlushCommands() {
|
|
|
|
rasterizer->FlushCommands();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Synchronizes CPU writes with Host GPU memory.
|
2022-02-06 01:16:11 +01:00
|
|
|
void InvalidateGPUCache() {
|
2023-12-25 07:32:16 +01:00
|
|
|
std::function<void(PAddr, size_t)> callback_writes(
|
|
|
|
[this](PAddr address, size_t size) { rasterizer->OnCacheInvalidation(address, size); });
|
2023-06-28 06:28:13 +02:00
|
|
|
system.GatherGPUDirtyMemory(callback_writes);
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Signal the ending of command list.
|
|
|
|
void OnCommandListEnd() {
|
2023-08-04 03:32:30 +02:00
|
|
|
rasterizer->ReleaseFences(false);
|
|
|
|
Settings::UpdateGPUAccuracy();
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Request a host GPU memory flush from the CPU.
|
2022-01-30 10:31:13 +01:00
|
|
|
template <typename Func>
|
|
|
|
[[nodiscard]] u64 RequestSyncOperation(Func&& action) {
|
|
|
|
std::unique_lock lck{sync_request_mutex};
|
|
|
|
const u64 fence = ++last_sync_fence;
|
|
|
|
sync_requests.emplace_back(action);
|
2021-10-01 06:57:02 +02:00
|
|
|
return fence;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Obtains current flush request fence id.
|
2022-01-30 10:31:13 +01:00
|
|
|
[[nodiscard]] u64 CurrentSyncRequestFence() const {
|
|
|
|
return current_sync_fence.load(std::memory_order_relaxed);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaitForSyncOperation(const u64 fence) {
|
|
|
|
std::unique_lock lck{sync_request_mutex};
|
|
|
|
sync_request_cv.wait(lck, [this, fence] { return CurrentSyncRequestFence() >= fence; });
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Tick pending requests within the GPU.
|
|
|
|
void TickWork() {
|
2022-01-30 10:31:13 +01:00
|
|
|
std::unique_lock lck{sync_request_mutex};
|
|
|
|
while (!sync_requests.empty()) {
|
|
|
|
auto request = std::move(sync_requests.front());
|
|
|
|
sync_requests.pop_front();
|
|
|
|
sync_request_mutex.unlock();
|
|
|
|
request();
|
|
|
|
current_sync_fence.fetch_add(1, std::memory_order_release);
|
|
|
|
sync_request_mutex.lock();
|
|
|
|
sync_request_cv.notify_all();
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the Maxwell3D GPU engine.
|
|
|
|
[[nodiscard]] Engines::Maxwell3D& Maxwell3D() {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->maxwell_3d;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a const reference to the Maxwell3D GPU engine.
|
|
|
|
[[nodiscard]] const Engines::Maxwell3D& Maxwell3D() const {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->maxwell_3d;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the KeplerCompute GPU engine.
|
|
|
|
[[nodiscard]] Engines::KeplerCompute& KeplerCompute() {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->kepler_compute;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the KeplerCompute GPU engine.
|
|
|
|
[[nodiscard]] const Engines::KeplerCompute& KeplerCompute() const {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->kepler_compute;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the GPU DMA pusher.
|
|
|
|
[[nodiscard]] Tegra::DmaPusher& DmaPusher() {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->dma_pusher;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a const reference to the GPU DMA pusher.
|
|
|
|
[[nodiscard]] const Tegra::DmaPusher& DmaPusher() const {
|
2021-11-05 15:52:31 +01:00
|
|
|
ASSERT(current_channel);
|
|
|
|
return *current_channel->dma_pusher;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the underlying renderer.
|
|
|
|
[[nodiscard]] VideoCore::RendererBase& Renderer() {
|
|
|
|
return *renderer;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a const reference to the underlying renderer.
|
|
|
|
[[nodiscard]] const VideoCore::RendererBase& Renderer() const {
|
|
|
|
return *renderer;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a reference to the shader notifier.
|
|
|
|
[[nodiscard]] VideoCore::ShaderNotify& ShaderNotify() {
|
|
|
|
return *shader_notify;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a const reference to the shader notifier.
|
|
|
|
[[nodiscard]] const VideoCore::ShaderNotify& ShaderNotify() const {
|
|
|
|
return *shader_notify;
|
|
|
|
}
|
|
|
|
|
|
|
|
[[nodiscard]] u64 GetTicks() const {
|
2023-05-28 23:45:47 +02:00
|
|
|
u64 gpu_tick = system.CoreTiming().GetGPUTicks();
|
2021-10-01 06:57:02 +02:00
|
|
|
|
|
|
|
if (Settings::values.use_fast_gpu_time.GetValue()) {
|
2023-05-28 23:45:47 +02:00
|
|
|
gpu_tick /= 256;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
2023-04-23 06:01:08 +02:00
|
|
|
|
2023-05-28 23:45:47 +02:00
|
|
|
return gpu_tick;
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
[[nodiscard]] bool IsAsync() const {
|
|
|
|
return is_async;
|
|
|
|
}
|
|
|
|
|
|
|
|
[[nodiscard]] bool UseNvdec() const {
|
|
|
|
return use_nvdec;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RendererFrameEndNotify() {
|
|
|
|
system.GetPerfStats().EndGameFrame();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Performs any additional setup necessary in order to begin GPU emulation.
|
|
|
|
/// This can be used to launch any necessary threads and register any necessary
|
|
|
|
/// core timing events.
|
|
|
|
void Start() {
|
2023-08-04 03:32:30 +02:00
|
|
|
Settings::UpdateGPUAccuracy();
|
2021-11-05 15:52:31 +01:00
|
|
|
gpu_thread.StartThread(*renderer, renderer->Context(), *scheduler);
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
2022-01-04 02:31:51 +01:00
|
|
|
void NotifyShutdown() {
|
|
|
|
std::unique_lock lk{sync_mutex};
|
|
|
|
shutting_down.store(true, std::memory_order::relaxed);
|
|
|
|
sync_cv.notify_all();
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
/// Obtain the CPU Context
|
|
|
|
void ObtainContext() {
|
2022-12-13 18:30:15 +01:00
|
|
|
if (!cpu_context) {
|
|
|
|
cpu_context = renderer->GetRenderWindow().CreateSharedContext();
|
|
|
|
}
|
2021-10-01 06:57:02 +02:00
|
|
|
cpu_context->MakeCurrent();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Release the CPU Context
|
|
|
|
void ReleaseContext() {
|
|
|
|
cpu_context->DoneCurrent();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Push GPU command entries to be processed
|
2021-11-05 15:52:31 +01:00
|
|
|
void PushGPUEntries(s32 channel, Tegra::CommandList&& entries) {
|
|
|
|
gpu_thread.SubmitList(channel, std::move(entries));
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
|
2023-12-25 07:32:16 +01:00
|
|
|
void FlushRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
gpu_thread.FlushRegion(addr, size);
|
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
VideoCore::RasterizerDownloadArea OnCPURead(DAddr addr, u64 size) {
|
2023-04-30 17:14:06 +02:00
|
|
|
auto raster_area = rasterizer->GetFlushArea(addr, size);
|
|
|
|
if (raster_area.preemtive) {
|
|
|
|
return raster_area;
|
|
|
|
}
|
|
|
|
raster_area.preemtive = true;
|
|
|
|
const u64 fence = RequestSyncOperation([this, &raster_area]() {
|
|
|
|
rasterizer->FlushRegion(raster_area.start_address,
|
|
|
|
raster_area.end_address - raster_area.start_address);
|
|
|
|
});
|
|
|
|
gpu_thread.TickGPU();
|
|
|
|
WaitForSyncOperation(fence);
|
|
|
|
return raster_area;
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be invalidated
|
2023-12-25 07:32:16 +01:00
|
|
|
void InvalidateRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
gpu_thread.InvalidateRegion(addr, size);
|
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
bool OnCPUWrite(DAddr addr, u64 size) {
|
2023-06-28 19:32:50 +02:00
|
|
|
return rasterizer->OnCPUWrite(addr, size);
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
/// Notify rasterizer that any caches of the specified region should be flushed and invalidated
|
2023-12-25 07:32:16 +01:00
|
|
|
void FlushAndInvalidateRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
gpu_thread.FlushAndInvalidateRegion(addr, size);
|
|
|
|
}
|
|
|
|
|
2024-01-22 18:40:50 +01:00
|
|
|
void RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,
|
|
|
|
std::vector<Service::Nvidia::NvFence>&& fences) {
|
|
|
|
size_t num_fences{fences.size()};
|
2022-01-30 10:31:13 +01:00
|
|
|
size_t current_request_counter{};
|
|
|
|
{
|
|
|
|
std::unique_lock<std::mutex> lk(request_swap_mutex);
|
|
|
|
if (free_swap_counters.empty()) {
|
|
|
|
current_request_counter = request_swap_counters.size();
|
|
|
|
request_swap_counters.emplace_back(num_fences);
|
|
|
|
} else {
|
|
|
|
current_request_counter = free_swap_counters.front();
|
|
|
|
request_swap_counters[current_request_counter] = num_fences;
|
|
|
|
free_swap_counters.pop_front();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
const auto wait_fence =
|
2024-01-22 18:40:50 +01:00
|
|
|
RequestSyncOperation([this, current_request_counter, &layers, &fences, num_fences] {
|
2022-01-30 10:31:13 +01:00
|
|
|
auto& syncpoint_manager = host1x.GetSyncpointManager();
|
|
|
|
if (num_fences == 0) {
|
2024-01-22 18:40:50 +01:00
|
|
|
renderer->Composite(layers);
|
2022-01-30 10:31:13 +01:00
|
|
|
}
|
2024-01-22 18:40:50 +01:00
|
|
|
const auto executer = [this, current_request_counter, layers_copy = layers]() {
|
2022-01-30 10:31:13 +01:00
|
|
|
{
|
|
|
|
std::unique_lock<std::mutex> lk(request_swap_mutex);
|
|
|
|
if (--request_swap_counters[current_request_counter] != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
free_swap_counters.push_back(current_request_counter);
|
|
|
|
}
|
2024-01-22 18:40:50 +01:00
|
|
|
renderer->Composite(layers_copy);
|
2022-01-30 10:31:13 +01:00
|
|
|
};
|
|
|
|
for (size_t i = 0; i < num_fences; i++) {
|
|
|
|
syncpoint_manager.RegisterGuestAction(fences[i].id, fences[i].value, executer);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
gpu_thread.TickGPU();
|
|
|
|
WaitForSyncOperation(wait_fence);
|
|
|
|
}
|
|
|
|
|
2024-01-26 22:10:21 +01:00
|
|
|
std::vector<u8> GetAppletCaptureBuffer() {
|
|
|
|
std::vector<u8> out;
|
|
|
|
|
|
|
|
const auto wait_fence =
|
|
|
|
RequestSyncOperation([&] { out = renderer->GetAppletCaptureBuffer(); });
|
|
|
|
gpu_thread.TickGPU();
|
|
|
|
WaitForSyncOperation(wait_fence);
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
GPU& gpu;
|
|
|
|
Core::System& system;
|
2022-01-30 10:31:13 +01:00
|
|
|
Host1x::Host1x& host1x;
|
2021-11-05 15:52:31 +01:00
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
std::unique_ptr<VideoCore::RendererBase> renderer;
|
|
|
|
VideoCore::RasterizerInterface* rasterizer = nullptr;
|
|
|
|
const bool use_nvdec;
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
s32 new_channel_id{1};
|
2021-10-01 06:57:02 +02:00
|
|
|
/// Shader build notifier
|
|
|
|
std::unique_ptr<VideoCore::ShaderNotify> shader_notify;
|
2022-01-04 02:28:54 +01:00
|
|
|
/// When true, we are about to shut down emulation session, so terminate outstanding tasks
|
|
|
|
std::atomic_bool shutting_down{};
|
2021-10-01 06:57:02 +02:00
|
|
|
|
|
|
|
std::array<std::atomic<u32>, Service::Nvidia::MaxSyncPoints> syncpoints{};
|
|
|
|
|
|
|
|
std::array<std::list<u32>, Service::Nvidia::MaxSyncPoints> syncpt_interrupts;
|
|
|
|
|
|
|
|
std::mutex sync_mutex;
|
|
|
|
std::mutex device_mutex;
|
|
|
|
|
2022-01-04 02:28:54 +01:00
|
|
|
std::condition_variable sync_cv;
|
2021-10-01 06:57:02 +02:00
|
|
|
|
2022-09-01 05:45:22 +02:00
|
|
|
std::list<std::function<void()>> sync_requests;
|
2022-01-30 10:31:13 +01:00
|
|
|
std::atomic<u64> current_sync_fence{};
|
|
|
|
u64 last_sync_fence{};
|
|
|
|
std::mutex sync_request_mutex;
|
|
|
|
std::condition_variable sync_request_cv;
|
2021-10-01 06:57:02 +02:00
|
|
|
|
|
|
|
const bool is_async;
|
|
|
|
|
|
|
|
VideoCommon::GPUThread::ThreadManager gpu_thread;
|
|
|
|
std::unique_ptr<Core::Frontend::GraphicsContext> cpu_context;
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
std::unique_ptr<Tegra::Control::Scheduler> scheduler;
|
|
|
|
std::unordered_map<s32, std::shared_ptr<Tegra::Control::ChannelState>> channels;
|
|
|
|
Tegra::Control::ChannelState* current_channel;
|
|
|
|
s32 bound_channel{-1};
|
2022-01-30 10:31:13 +01:00
|
|
|
|
|
|
|
std::deque<size_t> free_swap_counters;
|
|
|
|
std::deque<size_t> request_swap_counters;
|
|
|
|
std::mutex request_swap_mutex;
|
2021-10-01 06:57:02 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
GPU::GPU(Core::System& system, bool is_async, bool use_nvdec)
|
|
|
|
: impl{std::make_unique<Impl>(*this, system, is_async, use_nvdec)} {}
|
2018-03-18 21:15:05 +01:00
|
|
|
|
|
|
|
GPU::~GPU() = default;
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
std::shared_ptr<Control::ChannelState> GPU::AllocateChannel() {
|
|
|
|
return impl->AllocateChannel();
|
|
|
|
}
|
|
|
|
|
2024-02-24 04:38:21 +01:00
|
|
|
void GPU::InitChannel(Control::ChannelState& to_init, u64 program_id) {
|
|
|
|
impl->InitChannel(to_init, program_id);
|
2021-10-01 06:57:02 +02:00
|
|
|
}
|
2020-06-11 05:58:57 +02:00
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void GPU::BindChannel(s32 channel_id) {
|
|
|
|
impl->BindChannel(channel_id);
|
2020-06-11 05:58:57 +02:00
|
|
|
}
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void GPU::ReleaseChannel(Control::ChannelState& to_release) {
|
|
|
|
impl->ReleaseChannel(to_release);
|
|
|
|
}
|
|
|
|
|
2022-01-01 22:03:37 +01:00
|
|
|
void GPU::InitAddressSpace(Tegra::MemoryManager& memory_manager) {
|
|
|
|
impl->InitAddressSpace(memory_manager);
|
|
|
|
}
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void GPU::BindRenderer(std::unique_ptr<VideoCore::RendererBase> renderer) {
|
|
|
|
impl->BindRenderer(std::move(renderer));
|
2018-07-21 00:31:36 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
void GPU::FlushCommands() {
|
|
|
|
impl->FlushCommands();
|
2018-03-22 21:19:35 +01:00
|
|
|
}
|
|
|
|
|
2022-02-06 01:16:11 +01:00
|
|
|
void GPU::InvalidateGPUCache() {
|
|
|
|
impl->InvalidateGPUCache();
|
2019-07-15 03:25:13 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
void GPU::OnCommandListEnd() {
|
|
|
|
impl->OnCommandListEnd();
|
2019-07-15 03:25:13 +02:00
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
u64 GPU::RequestFlush(DAddr addr, std::size_t size) {
|
2022-01-30 10:31:13 +01:00
|
|
|
return impl->RequestSyncOperation(
|
|
|
|
[this, addr, size]() { impl->rasterizer->FlushRegion(addr, size); });
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 GPU::CurrentSyncRequestFence() const {
|
|
|
|
return impl->CurrentSyncRequestFence();
|
2018-08-28 16:57:56 +02:00
|
|
|
}
|
|
|
|
|
2022-01-30 10:31:13 +01:00
|
|
|
void GPU::WaitForSyncOperation(u64 fence) {
|
|
|
|
return impl->WaitForSyncOperation(fence);
|
2018-08-28 16:57:56 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
void GPU::TickWork() {
|
|
|
|
impl->TickWork();
|
2018-11-24 05:20:56 +01:00
|
|
|
}
|
|
|
|
|
2022-01-30 10:31:13 +01:00
|
|
|
/// Gets a mutable reference to the Host1x interface
|
|
|
|
Host1x::Host1x& GPU::Host1x() {
|
|
|
|
return impl->host1x;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Gets an immutable reference to the Host1x interface.
|
|
|
|
const Host1x::Host1x& GPU::Host1x() const {
|
|
|
|
return impl->host1x;
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
Engines::Maxwell3D& GPU::Maxwell3D() {
|
|
|
|
return impl->Maxwell3D();
|
2020-10-27 04:07:36 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
const Engines::Maxwell3D& GPU::Maxwell3D() const {
|
|
|
|
return impl->Maxwell3D();
|
2018-11-24 05:20:56 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
Engines::KeplerCompute& GPU::KeplerCompute() {
|
|
|
|
return impl->KeplerCompute();
|
2020-10-27 04:07:36 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
const Engines::KeplerCompute& GPU::KeplerCompute() const {
|
|
|
|
return impl->KeplerCompute();
|
2019-06-07 18:56:30 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
Tegra::DmaPusher& GPU::DmaPusher() {
|
|
|
|
return impl->DmaPusher();
|
|
|
|
}
|
2019-06-19 02:53:21 +02:00
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
const Tegra::DmaPusher& GPU::DmaPusher() const {
|
|
|
|
return impl->DmaPusher();
|
2019-06-08 03:13:20 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
VideoCore::RendererBase& GPU::Renderer() {
|
|
|
|
return impl->Renderer();
|
|
|
|
}
|
2020-02-13 23:16:07 +01:00
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
const VideoCore::RendererBase& GPU::Renderer() const {
|
|
|
|
return impl->Renderer();
|
2020-02-10 15:32:51 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
VideoCore::ShaderNotify& GPU::ShaderNotify() {
|
|
|
|
return impl->ShaderNotify();
|
2021-05-16 02:34:20 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
const VideoCore::ShaderNotify& GPU::ShaderNotify() const {
|
|
|
|
return impl->ShaderNotify();
|
2019-07-26 20:20:43 +02:00
|
|
|
}
|
|
|
|
|
2024-01-22 18:40:50 +01:00
|
|
|
void GPU::RequestComposite(std::vector<Tegra::FramebufferConfig>&& layers,
|
|
|
|
std::vector<Service::Nvidia::NvFence>&& fences) {
|
|
|
|
impl->RequestComposite(std::move(layers), std::move(fences));
|
2022-01-30 10:31:13 +01:00
|
|
|
}
|
|
|
|
|
2024-01-26 22:10:21 +01:00
|
|
|
std::vector<u8> GPU::GetAppletCaptureBuffer() {
|
|
|
|
return impl->GetAppletCaptureBuffer();
|
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
u64 GPU::GetTicks() const {
|
|
|
|
return impl->GetTicks();
|
2020-04-20 08:16:56 +02:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
bool GPU::IsAsync() const {
|
|
|
|
return impl->IsAsync();
|
2019-01-30 03:49:18 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
bool GPU::UseNvdec() const {
|
|
|
|
return impl->UseNvdec();
|
2019-01-30 03:49:18 +01:00
|
|
|
}
|
|
|
|
|
2021-10-01 06:57:02 +02:00
|
|
|
void GPU::RendererFrameEndNotify() {
|
|
|
|
impl->RendererFrameEndNotify();
|
2019-01-30 03:49:18 +01:00
|
|
|
}
|
|
|
|
|
2020-12-12 07:26:14 +01:00
|
|
|
void GPU::Start() {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->Start();
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2022-01-04 02:31:51 +01:00
|
|
|
void GPU::NotifyShutdown() {
|
|
|
|
impl->NotifyShutdown();
|
|
|
|
}
|
|
|
|
|
2020-12-12 07:26:14 +01:00
|
|
|
void GPU::ObtainContext() {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->ObtainContext();
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GPU::ReleaseContext() {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->ReleaseContext();
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2021-11-05 15:52:31 +01:00
|
|
|
void GPU::PushGPUEntries(s32 channel, Tegra::CommandList&& entries) {
|
|
|
|
impl->PushGPUEntries(channel, std::move(entries));
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
VideoCore::RasterizerDownloadArea GPU::OnCPURead(PAddr addr, u64 size) {
|
2023-04-30 17:14:06 +02:00
|
|
|
return impl->OnCPURead(addr, size);
|
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
void GPU::FlushRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->FlushRegion(addr, size);
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
void GPU::InvalidateRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->InvalidateRegion(addr, size);
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
bool GPU::OnCPUWrite(DAddr addr, u64 size) {
|
2023-06-28 19:32:50 +02:00
|
|
|
return impl->OnCPUWrite(addr, size);
|
|
|
|
}
|
|
|
|
|
2023-12-25 07:32:16 +01:00
|
|
|
void GPU::FlushAndInvalidateRegion(DAddr addr, u64 size) {
|
2021-10-01 06:57:02 +02:00
|
|
|
impl->FlushAndInvalidateRegion(addr, size);
|
2020-12-12 07:26:14 +01:00
|
|
|
}
|
|
|
|
|
2018-03-18 21:15:05 +01:00
|
|
|
} // namespace Tegra
|