[video_core] cpu buffer fix + kepler uploads / maxwell macro dirty tracking fixes

Addresses #4383.

Makes it so both the Qt and SDL frontends now share the same options (bar `-hlaunch` and `-qlaunch`).

Signed-off-by: lizzie <lizzie@eden-emu.dev>

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md)
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4424
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: Maufeat <sahyno1996@gmail.com>

docs/user/CommandLine.md

@@ -1,32 +1,44 @@
 # User Handbook - Command Line
 
-There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments.
+There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept the same command line arguments.
-
-## eden
 
 - `./eden <path>`: Running with a single argument and nothing else, will make the emulator look for the given file and load it, this behavior is similar to `eden-cli`; allows dragging and dropping games into the application.
-- `-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
+- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
-- `-f`: Use fullscreen.
+- `--config/-c`: Specify alternate configuration file.
-- `-u <number>`: Select the index of the user to load as.
+- `--fullscreen/-f`: Use fullscreen.
-- `-input-profile <name>`: Specifies input profile name to use (for player #0 only).
+- `--help/-h`: Display help.
+- `--game/-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
+- `--multiplayer/-m`: Specify multiplayer options.
+- `--program/-p`: Specify the program arguments to pass (optional).
+- `--user/-u <number>`: Specify the user index.
+- `--version/-v`: Display version and quit.
+- `--input-profile/-i <name>`: Specifies input profile name to use (for player #0 only).
+- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
+- `--filter/-x`: Sets the debug log filter irrespective of settings.
+- `--singlecore/-s`: Forces single-core regardless of settings.
+
+Only the Qt frontend supports the following arguments:
+
 - `-qlaunch`: Launch QLaunch.
 - `-hlaunch`: Launch homebrew launcher `nx-hbloader`.
     - Requires a copy of Atmosphere to be extracted onto `sdmc`.
     - This is a shorthand for `<eden folder>/sdmc/atmosphere/hbl.nsp`.
 - `-setup`: Launch setup applet.
 
-## eden-cli
+`eden` (provided with `--room`), and `eden-room` supports the following options as well:
 
-- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
+- `-n/--room-name`: The name of the room.
-- `--config/-c`: Specify alternate configuration file.
+- `-d/--room-description`: The room description.
-- `--fullscreen/-f`: Set fullscreen.
+- `-s/--bind-address`: The bind address for the room.
-- `--help/-h`: Display help.
+- `-p/--port`: The port used for the room.
-- `--game/-g`: Specify the game to run.
+- `-m/--max-members`: The maximum number of players for this room.
-- `--multiplayer/-m`: Specify multiplayer options.
+- `-w/--password`: The password for the room.
-- `--program/-p`: Specify the program arguments to pass (optional).
+- `-g/--preferred-game`: The preferred game for this room.
-- `--user/-u`: Specify the user index.
+- `-i/--preferred-game-id`: The preferred game-id for this room.
-- `--version/-v`: Display version and quit.
+- `-u/--username`: The username used for announce.
-- `--input-profile/-i`: Specifies input profile name to use (for player #0 only).
+- `-t/--token`: The token used for announce.
-- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
+- `-a/--web-api-url`: yuzu Web API url.
-- `--filter/-x`: Sets the debug log filter irrespective of settings.
+- `-b/--ban-list-file`: The file for storing the room ban list.
-- `--singlecore/-s`: Forces single-core regardless of settings.
+- `-l/--log-file`: The file for storing the room log.
+- `-h/--help`: Display this help and exit.
+- `-v/--version`: Output version information and exit.

src/common/sparse_large_vector.cpp

@@ -96,6 +96,21 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
 #ifndef MAP_NOCORE
 #define MAP_NOCORE 0
 #endif
+#ifndef MADV_FREE
+#define MADV_FREE MADV_DONTNEED
+#endif
+
+void DecommitVectorPage(uintptr_t base) noexcept {
+#if defined(_WIN32)
+    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
+#elif defined(__linux__)
+    // Linux's MADV_DONTNEED zeros out pages for us
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
+#else
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
+    std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
+#endif
+}
 
 void* AllocateMemoryPages(std::size_t size) noexcept {
     if (auto page = HostPageSize; size % page != 0) {

src/common/sparse_large_vector.h

@@ -35,6 +35,7 @@ const u64 HostPageMask = ~(HostPageSize - 1);
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
 void FreeMemoryPages(void* base, std::size_t size) noexcept;
+void DecommitVectorPage(uintptr_t base) noexcept;
 
 /// A large page-aligned buffer that has optimized memory usage for zero-writes.
 template <typename T>
@@ -114,7 +115,7 @@ public:
         const u64 end_page = AlignUp(base, HostPageSize);
         const u64 first_size = (std::min)(end_page, end) - base;
 
-        if (IsCommittedPage(start / sizeof(T))) {
+        if (IsCommittedPage(start)) {
             std::memset(reinterpret_cast<void*>(base), 0, first_size);
         }
 
@@ -124,11 +125,16 @@ public:
         base = end_page;
 
         for (u64 page = base; page < end; page += HostPageSize) {
-            if (!IsCommittedPage((page - reinterpret_cast<u64>(base_ptr)) / sizeof(T))) {
+            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
+            if (!IsCommittedPage(index)) {
                 continue;
             }
 
-            std::memset(reinterpret_cast<void*>(page), 0, (std::min)( HostPageSize, end - page));
+            if (end - page >= HostPageSize) {
+                DecommitPage(index);
+            } else {
+                std::memset(reinterpret_cast<void*>(page), 0, end - page);
+            }
         }
     }
 
@@ -183,6 +189,14 @@ private:
         committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
     }
 
+    constexpr void DecommitPage(std::size_t index) noexcept {
+        auto page_index = (index * sizeof(T)) >> HostPageBits;
+        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
+
+        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
+        DecommitVectorPage(page);
+    }
+
     std::size_t alloc_size{};
     T* base_ptr{};
 

src/core/CMakeLists.txt

@@ -23,6 +23,8 @@ add_library(core STATIC
     core_timing.h
     cpu_manager.cpp
     cpu_manager.h
+    launch_params.cpp
+    launch_params.h
     crypto/aes_util.cpp
     crypto/aes_util.h
     crypto/ctr_encryption_layer.cpp
@@ -1203,6 +1205,9 @@ endif()
 
 target_include_directories(core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)
+if (MSVC)
+    target_link_libraries(core PRIVATE getopt)
+endif()
 
 if (BOOST_NO_HEADERS)
     target_link_libraries(core PUBLIC Boost::container Boost::heap Boost::asio Boost::process Boost::crc)

src/core/hle/service/audio/audio.cpp

@@ -191,7 +191,7 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService("audout:d", std::make_shared<IAudioOutManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audin:d", std::make_shared<IAudioInManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audrec:d", std::make_shared<IFinalOutputRecorderManagerForDebugger>(system), 30);
-    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioInManager>(system), 30);
+    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioRendererManagerForDebugger>(system), 30);
 
     server_manager->RegisterNamedService("audin:u", std::make_shared<IAudioInManager>(system), 30);
     server_manager->RegisterNamedService("audin:a", std::make_shared<IAudioInManagerForApplet>(system), 30);

src/core/launch_params.cpp

@@ -0,0 +1,205 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <regex>
+#include <cctype>
+
+#include "common/assert.h"
+#include "common/logging.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "common/scm_rev.h"
+#include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/launch_params.h"
+
+#undef _UNICODE
+#include <getopt.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+namespace Core {
+LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept {
+    LaunchParams p{};
+
+    int option_index = 0;
+    static struct option long_options[] = {
+        // clang-format off
+        {"debug", no_argument, 0, 'd'},
+        {"config", required_argument, 0, 'c'},
+        {"fullscreen", no_argument, 0, 'f'},
+        {"help", no_argument, 0, 'h'},
+        {"game", required_argument, 0, 'g'},
+        {"multiplayer", required_argument, 0, 'm'},
+        {"program", optional_argument, 0, 'p'},
+        {"user", required_argument, 0, 'u'},
+        {"version", no_argument, 0, 'v'},
+        {"input-profile", no_argument, 0, 'i'},
+        {"null-render", no_argument, 0, 'n'},
+        {"singlecore", no_argument, 0, 's'},
+        {"filter", no_argument, 0, 'x'},
+        {0, 0, 0, 0},
+        // clang-format on
+    };
+
+    while (optind < argc) {
+        if (int arg = getopt_long(argc, argv, "dc:fhg:m:p:u:vinsx", long_options, &option_index); arg != -1) {
+            switch (char(arg)) {
+            case 'd':
+                p.override_gdb_port = uint16_t(atoi(optarg));
+                break;
+            case 'c':
+                p.config_path = optarg;
+                break;
+            case 'f':
+                p.fullscreen = true;
+                LOG_INFO(Frontend, "Starting in fullscreen mode...");
+                break;
+            case 'h':
+                p.print_help = true;
+                break;
+            case 'g':
+                p.filepath = std::string(optarg);
+                break;
+            case 'i': {
+                p.input_profile = std::string(optarg);
+                break;
+            }
+            case 'm': {
+                p.use_multiplayer = true;
+                const std::string str_arg(optarg);
+                // regex to check if the format is nickname:password@ip:port
+                // with optional :password
+                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
+                if (std::regex_match(str_arg, re)) {
+                    std::smatch match;
+                    std::regex_search(str_arg, match, re);
+                    ASSERT(match.size() == 5);
+                    p.nickname = match[1];
+                    p.password = match[2];
+                    p.address = match[3];
+                    if (!match[4].str().empty()) {
+                        p.port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
+                    }
+                    std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
+                    ASSERT(std::regex_match(p.nickname, nickname_re) && "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
+                    ASSERT(!p.address.empty() && "Address is empty");
+                }
+                break;
+            }
+            case 'p':
+                p.program_args = argv[optind];
+                ++optind;
+                break;
+            case 'u': {
+                // Launch game with a specific user
+                bool argument_ok = isdigit(optarg[0]);
+                p.selected_user = atoi(optarg);
+                if (!argument_ok) {
+                    // try to look it up by username, only finds the first username that matches.
+                    auto const user_idx = system.GetProfileManager().GetUserIndex(optarg);
+                    if (user_idx != std::nullopt) {
+                        p.selected_user = user_idx.value();
+                    } else {
+                        LOG_ERROR(Frontend, "Invalid user argument '{}'", optarg);
+                        break;
+                    }
+                }
+                if (system.GetProfileManager().UserExistsIndex(*p.selected_user)) {
+                    Settings::values.current_user = s32(*p.selected_user);
+                } else {
+                    LOG_ERROR(Frontend, "Selected user {} doesn't exist", *p.selected_user);
+                }
+                break;
+            }
+            case 'v':
+                p.print_version = true;
+                break;
+            case 'n':
+                p.force_null_render = true;
+                break;
+            case 's':
+                p.force_single_core = true;
+                break;
+            case 'x':
+                p.log_filter = argv[optind];
+                ++optind;
+                break;
+            }
+        } else {
+            // only kept due to shortcuts made by Qt frontend which use "-qlaunch"
+            if (strcmp(argv[optind], "-hlaunch") == 0) {
+                p.launch_hlaunch = true;
+            } else if (strcmp(argv[optind], "-qlaunch") == 0) {
+                p.launch_qlaunch = true;
+            } else if (strcmp(argv[optind], "-setup") == 0) {
+                p.launch_setup = true;
+            } else {
+                // qt feeds utf8 data, sdl frontend feeds raw utf16 data
+#ifdef _WIN32
+                p.filepath = argv_w != nullptr
+                    ? Common::UTF16ToUTF8(argv_w[optind])
+                    : argv[optind];
+#else
+                p.filepath = argv[optind];
+#endif
+            }
+            optind++;
+        }
+    }
+    p.argv0 = argv[0];
+    return p;
+}
+
+void ApplyLaunchParams(LaunchParams const& lp) noexcept {
+    // apply the log_filter setting
+    // the logger was initialized before and doesn't pick up the filter on its own
+    Common::Log::Filter filter{};
+    filter.ParseFilterString(lp.log_filter.value_or(Settings::values.log_filter.GetValue()));
+    Common::Log::SetGlobalFilter(filter);
+
+    if (!lp.program_args.empty()) {
+        Settings::values.program_args = lp.program_args;
+    }
+    if (!lp.input_profile.empty()) {
+        auto& players = Settings::values.players.GetValue();
+        players[0].profile_name = lp.input_profile;
+    }
+    if (lp.selected_user.has_value()) {
+        Settings::values.current_user = std::clamp(*lp.selected_user, 0, 7);
+    }
+    if (lp.override_gdb_port.has_value()) {
+        Settings::values.use_gdbstub = true;
+        Settings::values.gdbstub_port = *lp.override_gdb_port;
+    }
+    if (lp.force_single_core) {
+        Settings::values.use_multi_core = false;
+    }
+    if (lp.force_null_render) {
+        Settings::values.renderer_backend = Settings::RendererBackend::Null;
+    }
+
+    if (lp.print_version) {
+        LOG_INFO(Frontend, "Eden {} {}", Common::g_scm_branch, Common::g_scm_desc);
+    }
+    if (lp.print_help) {
+        LOG_INFO(Frontend,
+            "Usage: {}"
+            " [options] <filename>\n"
+            "-c, --config          Load the specified configuration file\n"
+            "-f, --fullscreen      Start in fullscreen mode\n"
+            "-g, --game            File path of the game to load\n"
+            "-h, --help            Display this help and exit\n"
+            "-m, --multiplayer=nick:password@address:port"
+            " Nickname, password, address and port for multiplayer\n"
+            "-p, --program         Pass following string as arguments to executable\n"
+            "-u, --user            Select a specific user profile from 0 to 7\n"
+            "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
+            "-v, --version         Output version information and exit\n",
+            lp.argv0
+        );
+    }
+}
+
+}

src/core/launch_params.h

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <string>
+#include <optional>
+#include "common/common_types.h"
+#include "network/room.h"
+
+namespace Core {
+
+class System;
+struct LaunchParams {
+    std::string argv0{};
+    std::string filepath{};
+    std::string nickname{};
+    std::string password{};
+    std::string address{};
+    std::string input_profile{};
+    std::string program_args{};
+    std::optional<std::string> config_path{};
+    std::optional<int> selected_user{};
+    std::optional<u16> override_gdb_port{};
+    std::optional<std::string> log_filter{};
+    u16 port = Network::DefaultRoomPort;
+    bool use_multiplayer = false;
+    bool fullscreen = false;
+    bool force_null_render = false;
+    bool force_single_core = false;
+    // print
+    bool print_version = false;
+    bool print_help = false;
+    // qt
+    bool launch_hlaunch = false;
+    bool launch_qlaunch = false;
+    bool launch_setup = false;
+};
+
+LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept;
+void ApplyLaunchParams(LaunchParams const& lp) noexcept;
+
+}

src/shader_recompiler/backend/glsl/emit_glsl.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -28,11 +31,6 @@ struct FuncTraits<ReturnType_ (*)(Args...)> {
     using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
 };
 
-template <auto func, typename... Args>
-void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
-    inst->SetDefinition<Id>(func(ctx, std::forward<Args>(args)...));
-}
-
 template <typename ArgType>
 auto Arg(EmitContext& ctx, const IR::Value& arg) {
     if constexpr (std::is_same_v<ArgType, std::string_view>) {
@@ -53,21 +51,10 @@ auto Arg(EmitContext& ctx, const IR::Value& arg) {
 template <auto func, bool is_first_arg_inst, size_t... I>
 void Invoke(EmitContext& ctx, IR::Inst* inst, std::index_sequence<I...>) {
     using Traits = FuncTraits<decltype(func)>;
-    if constexpr (std::is_same_v<typename Traits::ReturnType, Id>) {
+    if constexpr (is_first_arg_inst) {
-        if constexpr (is_first_arg_inst) {
+        func(ctx, *inst, Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
-            SetDefinition<func>(
-                ctx, inst, *inst,
-                Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
-        } else {
-            SetDefinition<func>(
-                ctx, inst, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
-        }
     } else {
-        if constexpr (is_first_arg_inst) {
+        func(ctx, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
-            func(ctx, *inst, Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
-        } else {
-            func(ctx, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
-        }
     }
 }
 

src/video_core/buffer_cache/buffer_cache.h

@@ -121,7 +121,7 @@ void BufferCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size
 
 template <class P>
 void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
-    if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
+    if (IsRegionGpuModified(device_addr, size)) {
         ClearDownload(device_addr, size);
         gpu_modified_ranges.Subtract(device_addr, size);
     }
@@ -311,11 +311,8 @@ std::pair<typename P::Buffer*, u32> BufferCache<P>::ObtainCPUBuffer(
         MarkWrittenBuffer(buffer_id, device_addr, size);
         break;
     case ObtainBufferOperation::DiscardWrite: {
-        const DAddr device_addr_start = Common::AlignDown(device_addr, 64);
+        ClearDownload(device_addr, size);
-        const DAddr device_addr_end = Common::AlignUp(device_addr + size, 64);
+        gpu_modified_ranges.Subtract(device_addr, size);
-        const size_t new_size = device_addr_end - device_addr_start;
-        ClearDownload(device_addr_start, new_size);
-        gpu_modified_ranges.Subtract(device_addr_start, new_size);
         break;
     }
     default:
@@ -1742,14 +1739,24 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
     const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+    const auto add_upload = [&](DAddr start, DAddr end) {
+        if (start == end) return;
+        const u64 range_size = end - start;
         upload_copies.push_back(BufferCopy{
             .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
+            .dst_offset = start - buffer_start,
             .size = range_size,
         });
         total_size_bytes += range_size;
         largest_copy = (std::max)(largest_copy, range_size);
+    };
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+        DAddr upload_start = device_addr_out;
+        gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, [&](DAddr gpu_start, DAddr gpu_end) {
+            add_upload(upload_start, gpu_start);
+            upload_start = gpu_end;
+        });
+        add_upload(upload_start, device_addr_out + range_size);
     });
     if (total_size_bytes == 0) {
         return true;

src/video_core/dma_pusher.cpp

@@ -16,7 +16,7 @@
 namespace Tegra {
 
 constexpr u32 MacroRegistersStart = 0xE00;
-[[maybe_unused]] constexpr u32 ComputeInline = 0x6D;
+constexpr u32 ComputeInline = 0x6D;
 
 DmaPusher::DmaPusher(Core::System& system_, MemoryManager& memory_manager_, Control::ChannelState& channel_state_)
     : system{system_}
@@ -73,11 +73,16 @@ bool DmaPusher::Step() {
         synced = false;
     }
 
-    if (header.size > 0 && dma_state.method >= MacroRegistersStart && subchannels[dma_state.subchannel]) {
-        subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, header.size * sizeof(u32));
-    }
-
     if (header.size > 0) {
+        if (subchannels[dma_state.subchannel] && dma_state.method_count) {
+            const auto engine = subchannel_type[dma_state.subchannel];
+            const bool kepler_payload = engine == Engines::EngineTypes::KeplerCompute && dma_state.method == ComputeInline && dma_state.non_incrementing;
+            const bool macro_payload = engine == Engines::EngineTypes::Maxwell3D && dma_state.method >= MacroRegistersStart;
+            if (kepler_payload || macro_payload) {
+                const size_t words = std::min<size_t>(dma_state.method_count, header.size);
+                subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, words * sizeof(u32));
+            }
+        }
         const bool use_safe = Settings::IsDMALevelDefault() ? Settings::IsGPULevelHigh() : Settings::IsDMALevelSafe();
         if (use_safe) {
             Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader, Tegra::Memory::GuestMemoryFlags::SafeRead>headers(memory_manager, dma_state.dma_get, header.size, &command_headers);

src/video_core/engines/kepler_compute.cpp

@@ -49,13 +49,16 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu
     case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
         UploadInfo info{.upload_address = upload_address,
                         .exec_address = upload_state.ExecTargetAddress(),
-                        .copy_size = upload_state.GetUploadSize()};
+                        .copy_size = upload_state.GetUploadSize(),
+                        .was_dirty = upload_dirty};
         uploads.push_back(info);
         upload_state.ProcessExec(regs.exec_upload.linear != 0);
         break;
     }
     case KEPLER_COMPUTE_REG_INDEX(data_upload): {
         upload_address = current_dma_segment;
+        upload_dirty = current_dirty;
+        current_dirty = false;
         upload_state.ProcessData(method_argument, is_last_call);
         break;
     }
@@ -64,9 +67,11 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu
 
         for (auto& data : uploads) {
             const GPUVAddr offset = data.exec_address - launch_desc_loc;
-            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x) &&
+            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x)) {
-                memory_manager.IsMemoryDirty(data.upload_address, data.copy_size)) {
+                const bool source_dirty = memory_manager.IsMemoryDirty(data.upload_address, data.copy_size);
-                indirect_compute = {data.upload_address};
+                if (data.was_dirty || source_dirty) {
+                    indirect_compute = {data.upload_address};
+                }
             }
         }
         uploads.clear();
@@ -83,6 +88,8 @@ void KeplerCompute::CallMultiMethod(Core::System& system, u32 method, const u32*
     switch (method) {
     case KEPLER_COMPUTE_REG_INDEX(data_upload):
         upload_address = current_dma_segment;
+        upload_dirty = current_dirty;
+        current_dirty = false;
         upload_state.ProcessData(base_start, amount);
         return;
     default:

src/video_core/engines/kepler_compute.h

@@ -226,11 +226,13 @@ private:
     VideoCore::RasterizerInterface* rasterizer = nullptr;
     Upload::State upload_state;
     GPUVAddr upload_address;
+    bool upload_dirty{};
 
     struct UploadInfo {
         GPUVAddr upload_address;
         GPUVAddr exec_address;
         u32 copy_size;
+        bool was_dirty;
     };
     std::vector<UploadInfo> uploads;
     std::optional<GPUVAddr> indirect_compute{};

src/yuzu/main_window.cpp

@@ -3,6 +3,7 @@
 
 // Static Qt on macOS doesn't use Vulkan
 // Other platforms do, and thus have conflicting VulkanMemoryAllocator symbols
+#include "core/launch_params.h"
 #if defined(QT_STATICPLUGIN) && !defined(__APPLE__)
 #undef VMA_IMPLEMENTATION
 #endif
@@ -515,79 +516,28 @@ MainWindow::MainWindow(bool has_broken_vulkan)
     // to prevent the UI from blowing up.
     UpdateUITheme();
 
-    QStringList args = QApplication::arguments();
+    if (QStringList args = QApplication::arguments(); args.size() >= 2) {
+        QList<QByteArray> qba{};
+        for (auto const& e : args)
+            qba.push_back(e.toUtf8());
+        std::vector<char*> args_cstr{};
+        for (auto& e : qba)
+            args_cstr.push_back(e.data());
 
-    if (args.size() < 2) {
+        auto const lp = Core::ParseLaunchParams(*QtCommon::system, args_cstr.size(), args_cstr.data(), nullptr);
-        return;
-    }
 
-    QString game_path;
+        // Override fullscreen setting if gamepath or argument is provided
-    bool should_launch_qlaunch = false;
+        if (!lp.filepath.empty() || lp.fullscreen) {
-    bool should_launch_hlaunch = false;
+            ui->action_Fullscreen->setChecked(lp.fullscreen);
-    bool should_launch_setup = false;
-    bool has_gamepath = false;
-    bool is_fullscreen = false;
-
-    // Preserves drag/drop functionality
-    for (int i = 1; i < args.size(); ++i) {
-        if (args[i] == QStringLiteral("-f")) {
-            // Launch game in fullscreen mode
-            is_fullscreen = true;
-        } else if (args[i] == QStringLiteral("-u") && i < args.size() - 1) {
-            // Launch game with a specific user
-            int user_arg_idx = ++i;
-            bool argument_ok;
-            std::size_t selected_user = args[user_arg_idx].toUInt(&argument_ok);
-            if (!argument_ok) {
-                // try to look it up by username, only finds the first username that matches.
-                std::string const user_arg_str = args[user_arg_idx].toStdString();
-                auto const user_idx =
-                    QtCommon::system->GetProfileManager().GetUserIndex(user_arg_str);
-                if (user_idx != std::nullopt) {
-                    selected_user = user_idx.value();
-                } else {
-                    LOG_ERROR(Frontend, "Invalid user argument '{}'", user_arg_str);
-                    continue;
-                }
-            }
-            if (QtCommon::system->GetProfileManager().UserExistsIndex(selected_user)) {
-                Settings::values.current_user = s32(selected_user);
-                user_flag_cmd_line = true;
-            } else {
-                LOG_ERROR(Frontend, "Selected user {} doesn't exist", selected_user);
-            }
-        } else if (args[i] == QStringLiteral("-g") && i < args.size() - 1) {
-            // Launch game at path
-            game_path = args[++i];
-            has_gamepath = true;
-        } else if (args[i] == QStringLiteral("-input-profile") && i < args.size() - 1) {
-            auto& players = Settings::values.players.GetValue();
-            players[0].profile_name = args[++i].toStdString();
-        } else if (args[i] == QStringLiteral("-qlaunch")) {
-            should_launch_qlaunch = true;
-        } else if (args[i] == QStringLiteral("-hlaunch")) {
-            should_launch_hlaunch = true;
-        } else if (args[i] == QStringLiteral("-setup")) {
-            should_launch_setup = true;
-        } else {
-            game_path = args[i];
-            has_gamepath = true;
         }
-    }
 
-    // Override fullscreen setting if gamepath or argument is provided
+        if (!lp.filepath.empty()) {
-    if (has_gamepath || is_fullscreen) {
+            BootGame(QString::fromStdString(lp.filepath), ApplicationAppletParameters());
-        ui->action_Fullscreen->setChecked(is_fullscreen);
+        } else if (lp.launch_setup) {
-    }
+            LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::Starter), std::nullopt);
-
+        } else if (lp.launch_qlaunch) {
-    if (should_launch_setup) {
-        LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::Starter), std::nullopt);
-    } else {
-        if (!game_path.isEmpty()) {
-            BootGame(game_path, ApplicationAppletParameters());
-        } else if (should_launch_qlaunch) {
             LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::QLaunch), std::nullopt);
-        } else if (should_launch_hlaunch) {
+        } else if (lp.launch_hlaunch) {
             std::filesystem::path const sd_dir =
                 Common::FS::GetEdenPathString(Common::FS::EdenPath::SDMCDir);
             auto const hbl_path = (sd_dir / "atmosphere" / "hbl.nsp").string();

src/yuzu_cmd/CMakeLists.txt

@@ -42,9 +42,6 @@ target_link_libraries(yuzu-cmd PRIVATE common core input_common frontend_common
 if (ENABLE_OPENGL)
     target_link_libraries(yuzu-cmd PRIVATE glad)
 endif()
-if (MSVC)
-    target_link_libraries(yuzu-cmd PRIVATE getopt)
-endif()
 target_link_libraries(yuzu-cmd PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
 create_resource("../../dist/eden.bmp" "yuzu_cmd/yuzu_icon.h" "yuzu_icon")

src/yuzu_cmd/yuzu.cpp

@@ -10,6 +10,7 @@
 #include <regex>
 #include <string>
 #include "common/settings_enums.h"
+#include "core/launch_params.h"
 #ifdef __EMSCRIPTEN__
 #include <emscripten.h>
 #endif
@@ -52,12 +53,6 @@
 #include "common/windows/timer_resolution.h"
 #endif
 
-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
 #ifdef _WIN32
 extern "C" {
 // tells Nvidia and AMD drivers to use the dedicated GPU by default on laptops with switchable
@@ -67,25 +62,6 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif
 
-static void PrintHelp(const char* argv0) {
-    std::cout << "Usage: " << argv0
-              << " [options] <filename>\n"
-                 "-c, --config          Load the specified configuration file\n"
-                 "-f, --fullscreen      Start in fullscreen mode\n"
-                 "-g, --game            File path of the game to load\n"
-                 "-h, --help            Display this help and exit\n"
-                 "-m, --multiplayer=nick:password@address:port"
-                 " Nickname, password, address and port for multiplayer\n"
-                 "-p, --program         Pass following string as arguments to executable\n"
-                 "-u, --user            Select a specific user profile from 0 to 7\n"
-                 "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
-                 "-v, --version         Output version information and exit\n";
-}
-
-static void PrintVersion() {
-    std::cout << "Eden " << Common::g_scm_branch << " " << Common::g_scm_desc << std::endl;
-}
-
 static void OnStateChanged(const Network::RoomMember::State& state) {
     switch (state) {
     case Network::RoomMember::State::Idle:
@@ -208,168 +184,18 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
         LOG_CRITICAL(Frontend, "Failed to get command line arguments");
         return SDL_APP_FAILURE;
     }
-#endif
-    std::string filepath;
-    std::optional<std::string> config_path{};
-    std::string program_args;
-    std::optional<int> selected_user{};
-    std::optional<u16> override_gdb_port{};
-    bool use_multiplayer = false;
-    bool fullscreen = false;
-    bool force_null_render = false;
-    bool force_single_core = false;
-    std::string nickname{};
-    std::string password{};
-    std::string address{};
-    std::string input_profile{};
-    std::optional<std::string> log_filter{};
-    u16 port = Network::DefaultRoomPort;
-
-    static struct option long_options[] = {
-        // clang-format off
-        {"debug", no_argument, 0, 'd'},
-        {"config", required_argument, 0, 'c'},
-        {"fullscreen", no_argument, 0, 'f'},
-        {"help", no_argument, 0, 'h'},
-        {"game", required_argument, 0, 'g'},
-        {"multiplayer", required_argument, 0, 'm'},
-        {"program", optional_argument, 0, 'p'},
-        {"user", required_argument, 0, 'u'},
-        {"version", no_argument, 0, 'v'},
-        {"input-profile", no_argument, 0, 'i'},
-        {"null-render", no_argument, 0, 'n'},
-        {"singlecore", no_argument, 0, 's'},
-        {"filter", no_argument, 0, 'x'},
-        {0, 0, 0, 0},
-        // clang-format on
-    };
-
-    while (optind < argc) {
-        int arg = getopt_long(argc, argv, "g:fhvcip::c:u:d:", long_options, &option_index);
-        if (arg != -1) {
-            switch (char(arg)) {
-            case 'd':
-                override_gdb_port = uint16_t(atoi(optarg));
-                break;
-            case 'c':
-                config_path = optarg;
-                break;
-            case 'f':
-                fullscreen = true;
-                LOG_INFO(Frontend, "Starting in fullscreen mode...");
-                break;
-            case 'h':
-                PrintHelp(argv[0]);
-                return SDL_APP_FAILURE;
-            case 'g':
-                filepath = std::string(optarg);
-                break;
-            case 'i': {
-                input_profile = std::string(optarg);
-                break;
-            }
-            case 'm': {
-                use_multiplayer = true;
-                const std::string str_arg(optarg);
-                // regex to check if the format is nickname:password@ip:port
-                // with optional :password
-                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
-                if (!std::regex_match(str_arg, re)) {
-                    std::cout << "Wrong format for option --multiplayer\n";
-                    PrintHelp(argv[0]);
-                    return SDL_APP_FAILURE;
-                }
-
-                std::smatch match;
-                std::regex_search(str_arg, match, re);
-                ASSERT(match.size() == 5);
-                nickname = match[1];
-                password = match[2];
-                address = match[3];
-                if (!match[4].str().empty()) {
-                    port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
-                }
-                std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
-                if (!std::regex_match(nickname, nickname_re)) {
-                    LOG_ERROR(Frontend, "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
-                    return SDL_APP_FAILURE;
-                }
-                if (address.empty()) {
-                    LOG_ERROR(Frontend, "Address to room must not be empty");
-                    return SDL_APP_FAILURE;
-                }
-                break;
-            }
-            case 'p':
-                program_args = argv[optind];
-                ++optind;
-                break;
-            case 'u':
-                selected_user = atoi(optarg);
-                break;
-            case 'v':
-                PrintVersion();
-                return SDL_APP_FAILURE;
-            case 'n':
-                force_null_render = true;
-                break;
-            case 's':
-                force_single_core = true;
-                break;
-            case 'x':
-                log_filter = argv[optind];
-                ++optind;
-                break;
-            }
-        } else {
-#ifdef _WIN32
-            filepath = Common::UTF16ToUTF8(argv_w[optind]);
 #else
-            filepath = argv[optind];
+    wchar_t **argv_w = nullptr;
 #endif
-            optind++;
+    Core::LaunchParams lp = Core::ParseLaunchParams(state->system, argc, argv, argv_w);
-        }
-    }
-
-    SdlConfig config{config_path};
-
-    // apply the log_filter setting
-    // the logger was initialized before and doesn't pick up the filter on its own
-    Common::Log::Filter filter;
-    filter.ParseFilterString(log_filter.value_or(Settings::values.log_filter.GetValue()));
-    Common::Log::SetGlobalFilter(filter);
-
-    if (!program_args.empty()) {
-        Settings::values.program_args = program_args;
-    }
-
-    if (!input_profile.empty()) {
-        auto& players = Settings::values.players.GetValue();
-        players[0].profile_name = input_profile;
-    }
-
-    if (selected_user.has_value()) {
-        Settings::values.current_user = std::clamp(*selected_user, 0, 7);
-    }
-
-    if (override_gdb_port.has_value()) {
-        Settings::values.use_gdbstub = true;
-        Settings::values.gdbstub_port = *override_gdb_port;
-    }
-
-    if (force_single_core) {
-        Settings::values.use_multi_core = false;
-    }
-
-    if (force_null_render) {
-        Settings::values.renderer_backend = Settings::RendererBackend::Null;
-    }
-
 #ifdef _WIN32
     LocalFree(argv_w);
 #endif
+    SdlConfig config{lp.config_path};
 
-    if (filepath.empty()) {
+    Core::ApplyLaunchParams(lp);
+
+    if (lp.filepath.empty()) {
         LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
         return SDL_APP_FAILURE;
     }
@@ -386,14 +212,14 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
     case Settings::RendererBackend::OpenGL_GLSL:
     case Settings::RendererBackend::OpenGL_GLASM:
     case Settings::RendererBackend::OpenGL_SPIRV:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state->system, lp.fullscreen);
         break;
 #endif
     case Settings::RendererBackend::Vulkan:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state->system, lp.fullscreen);
         break;
     case Settings::RendererBackend::Null:
-        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, fullscreen);
+        state->emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state->system, lp.fullscreen);
         break;
     default:
         LOG_CRITICAL(Frontend, "Invalid renderer backend");
@@ -413,12 +239,12 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
     Service::AM::FrontendAppletParameters load_parameters{
         .applet_id = Service::AM::AppletId::Application,
     };
-    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, filepath, load_parameters);
+    const Core::SystemResultStatus load_result = state->system.Load(*state->emu_window, lp.filepath, load_parameters);
     switch (load_result) {
     case Core::SystemResultStatus::Success:
         break; // Expected case
     case Core::SystemResultStatus::ErrorGetLoader:
-        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", lp.filepath);
         return SDL_APP_FAILURE;
     case Core::SystemResultStatus::ErrorLoader:
         LOG_CRITICAL(Frontend, "Failed to load ROM!");
@@ -440,14 +266,14 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
         return SDL_APP_FAILURE;
     }
 
-    if (use_multiplayer) {
+    if (lp.use_multiplayer) {
         if (auto member = Network::GetRoomMember().lock()) {
             member->BindOnChatMessageReceived(OnMessageReceived);
             member->BindOnStatusMessageReceived(OnStatusMessageReceived);
             member->BindOnStateChanged(OnStateChanged);
             member->BindOnError(OnNetworkError);
-            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port, nickname);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", lp.address, lp.port, lp.nickname);
-            member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
+            member->Join(lp.nickname, lp.address.c_str(), lp.port, 0, Network::NoPreferredIP, lp.password);
         } else {
             LOG_ERROR(Network, "Could not access RoomMember");
             return SDL_APP_FAILURE;