extra fixups

src/video_core/control/channel_state_cache.cpp

@@ -6,8 +6,11 @@
 namespace VideoCommon {
 
 ChannelInfo::ChannelInfo(Tegra::Control::ChannelState& channel_state)
-    : maxwell3d{*channel_state.maxwell_3d}, kepler_compute{*channel_state.kepler_compute},
-      gpu_memory{*channel_state.memory_manager}, program_id{channel_state.program_id} {}
+    : maxwell3d{channel_state.payload->maxwell_3d}
+    , kepler_compute{channel_state.payload->kepler_compute}
+    , gpu_memory{*channel_state.memory_manager}
+    , program_id{channel_state.program_id}
+  {}
 
 template class VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo>;
 

src/video_core/control/channel_state_cache.inc

@@ -41,7 +41,7 @@ void ChannelSetupCaches<P>::CreateChannel(struct Tegra::Control::ChannelState& c
     AddressSpaceRef new_gpu_mem_ref{
         .ref_count = 1,
         .storage_id = address_spaces.size(),
-        .gpu_memory = channel.memory_manager.get(),
+        .gpu_memory = channel.memory_manager,
     };
     address_spaces.emplace(channel.memory_manager->GetID(), new_gpu_mem_ref);
     OnGPUASRegister(channel.memory_manager->GetID());

src/video_core/control/scheduler.cpp

@@ -12,11 +12,8 @@
 #include "video_core/gpu.h"
 
 namespace Tegra::Control {
-Scheduler::Scheduler(GPU& gpu_) : gpu{gpu_} {}
 
-Scheduler::~Scheduler() = default;
-
-void Scheduler::Push(s32 channel, CommandList&& entries) {
+void Scheduler::Push(GPU& gpu, s32 channel, CommandList&& entries) {
     std::shared_ptr<ChannelState> channel_state;
     {
         std::unique_lock lk(scheduling_guard);
@@ -27,8 +24,8 @@ void Scheduler::Push(s32 channel, CommandList&& entries) {
     }
     // Process commands outside the lock to reduce contention.
     // Multiple channels can prepare their commands in parallel.
-    channel_state->dma_pusher->Push(std::move(entries));
-    channel_state->dma_pusher->DispatchCalls();
+    channel_state->payload->dma_pusher.Push(std::move(entries));
+    channel_state->payload->dma_pusher.DispatchCalls();
 }
 
 void Scheduler::DeclareChannel(std::shared_ptr<ChannelState> new_channel) {

src/video_core/control/scheduler.h

@@ -22,17 +22,13 @@ struct ChannelState;
 
 class Scheduler {
 public:
-    explicit Scheduler(GPU& gpu_);
-    ~Scheduler();
-
-    void Push(s32 channel, CommandList&& entries);
+    void Push(GPU& gpu, s32 channel, CommandList&& entries);
 
     void DeclareChannel(std::shared_ptr<ChannelState> new_channel);
 
 private:
     ankerl::unordered_dense::map<s32, std::shared_ptr<ChannelState>> channels;
     std::mutex scheduling_guard;
-    GPU& gpu;
 };
 
 } // namespace Control

src/video_core/engines/puller.cpp

@@ -29,22 +29,22 @@ void Puller::ProcessBindMethod(DmaPusher& dma_pusher, const MethodCall& method_c
     bound_engines[method_call.subchannel] = engine_id;
     switch (engine_id) {
     case EngineID::FERMI_TWOD_A:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.fermi_2d, method_call.subchannel, EngineTypes::Fermi2D);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->fermi_2d, method_call.subchannel, EngineTypes::Fermi2D);
         break;
     case EngineID::MAXWELL_B:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.maxwell_3d, method_call.subchannel, EngineTypes::Maxwell3D);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->maxwell_3d, method_call.subchannel, EngineTypes::Maxwell3D);
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.kepler_compute, method_call.subchannel, EngineTypes::KeplerCompute);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->kepler_compute, method_call.subchannel, EngineTypes::KeplerCompute);
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.maxwell_dma, method_call.subchannel, EngineTypes::MaxwellDMA);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->maxwell_dma, method_call.subchannel, EngineTypes::MaxwellDMA);
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.kepler_memory, method_call.subchannel, EngineTypes::KeplerMemory);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->kepler_memory, method_call.subchannel, EngineTypes::KeplerMemory);
         break;
     case EngineID::NV01_TIMER:
-        dma_pusher.BindSubchannel(&*dma_pusher.channel_state.nv01_timer, method_call.subchannel, EngineTypes::Nv01Timer);
+        dma_pusher.BindSubchannel(&dma_pusher.channel_state.payload->nv01_timer, method_call.subchannel, EngineTypes::Nv01Timer);
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", engine_id);
@@ -198,22 +198,22 @@ void Puller::CallEngineMethod(DmaPusher& dma_pusher, const MethodCall& method_ca
     const EngineID engine = bound_engines[method_call.subchannel];
     switch (engine) {
     case EngineID::FERMI_TWOD_A:
-        dma_pusher.channel_state.fermi_2d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->fermi_2d.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_B:
-        dma_pusher.channel_state.maxwell_3d->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->maxwell_3d.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        dma_pusher.channel_state.kepler_compute->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->kepler_compute.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        dma_pusher.channel_state.maxwell_dma->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->maxwell_dma.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        dma_pusher.channel_state.kepler_memory->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->kepler_memory.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     case EngineID::NV01_TIMER:
-        dma_pusher.channel_state.nv01_timer->CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
+        dma_pusher.channel_state.payload->nv01_timer.CallMethod(method_call.method, method_call.argument, method_call.IsLastCall());
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
@@ -226,22 +226,22 @@ void Puller::CallEngineMultiMethod(DmaPusher& dma_pusher, u32 method, u32 subcha
     const EngineID engine = bound_engines[subchannel];
     switch (engine) {
     case EngineID::FERMI_TWOD_A:
-        dma_pusher.channel_state.fermi_2d->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->fermi_2d.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     case EngineID::MAXWELL_B:
-        dma_pusher.channel_state.maxwell_3d->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->maxwell_3d.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     case EngineID::KEPLER_COMPUTE_B:
-        dma_pusher.channel_state.kepler_compute->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->kepler_compute.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     case EngineID::MAXWELL_DMA_COPY_A:
-        dma_pusher.channel_state.maxwell_dma->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->maxwell_dma.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     case EngineID::KEPLER_INLINE_TO_MEMORY_B:
-        dma_pusher.channel_state.kepler_memory->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->kepler_memory.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     case EngineID::NV01_TIMER:
-        dma_pusher.channel_state.nv01_timer->CallMultiMethod(method, base_start, amount, methods_pending);
+        dma_pusher.channel_state.payload->nv01_timer.CallMultiMethod(method, base_start, amount, methods_pending);
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");

src/video_core/gpu.cpp

@@ -46,7 +46,6 @@ struct GPU::Impl {
         , shader_notify()
         , is_async{is_async_}
         , gpu_thread{system_, is_async_}
-        , scheduler(system_.GPU())
     {}
 
     ~Impl() = default;
@@ -385,27 +384,27 @@ const Host1x::Host1x& GPU::Host1x() const {
 }
 
 Engines::Maxwell3D& GPU::Maxwell3D() {
-    return *impl->current_channel->maxwell_3d;
+    return impl->current_channel->payload->maxwell_3d;
 }
 
 const Engines::Maxwell3D& GPU::Maxwell3D() const {
-    return *impl->current_channel->maxwell_3d;
+    return impl->current_channel->payload->maxwell_3d;
 }
 
 Engines::KeplerCompute& GPU::KeplerCompute() {
-    return *impl->current_channel->kepler_compute;
+    return impl->current_channel->payload->kepler_compute;
 }
 
 const Engines::KeplerCompute& GPU::KeplerCompute() const {
-    return *impl->current_channel->kepler_compute;
+    return impl->current_channel->payload->kepler_compute;
 }
 
 Tegra::DmaPusher& GPU::DmaPusher() {
-    return *impl->current_channel->dma_pusher;
+    return impl->current_channel->payload->dma_pusher;
 }
 
 const Tegra::DmaPusher& GPU::DmaPusher() const {
-    return *impl->current_channel->dma_pusher;
+    return impl->current_channel->payload->dma_pusher;
 }
 
 VideoCore::RendererBase& GPU::Renderer() {

src/video_core/gpu_thread.cpp

@@ -40,7 +40,7 @@ void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Core::Fronten
                 break;
             }
             if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
-                scheduler.Push(submit_list->channel, std::move(submit_list->entries));
+                scheduler.Push(system.GPU(), submit_list->channel, std::move(submit_list->entries));
             } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
                 system.GPU().TickWork();
             } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {