Refactor Logging Impl

Loop on stop_token and remove final_entry in Entry.
Move Backend thread out of Impl Constructor to its own function.
Add Start function for backend thread.
Use stop token in PopWait and check if entry filename is nullptr before logging.

CMakeLists.txt

@@ -411,12 +411,13 @@ if (CONAN_REQUIRED_LIBS)
     # Download conan.cmake automatically, you can also just copy the conan.cmake file
     if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
         message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
+        # TODO: Use a tagged release. The latest tagged release does not support VS2022 as of this writing.
+        file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/43e385830ee35377dbd2dcbe8d5a9e750301ea00/conan.cmake"
                         "${CMAKE_BINARY_DIR}/conan.cmake")
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    conan_check(VERSION 1.24.0 REQUIRED)
+    conan_check(VERSION 1.41.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
     # We don't need to add it through find_package or anything since the other two can find it just fine

src/CMakeLists.txt

@@ -32,6 +32,7 @@ if (MSVC)
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
+    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
         /Zi
@@ -44,6 +45,7 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
+        /GT
 
         # External headers diagnostics
         /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -69,6 +71,10 @@ if (MSVC)
         /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
+    if (ARCHITECTURE_x86_64)
+        add_compile_options(/QIntel-jcc-erratum)
+    endif()
+
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
 

src/common/alignment.h

@@ -64,7 +64,7 @@ public:
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
     using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::true_type;
+    using is_always_equal = std::false_type;
 
     constexpr AlignmentAllocator() noexcept = default;
 
@@ -83,6 +83,11 @@ public:
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
+
+    template <typename T2, size_t Align2>
+    constexpr bool operator==(const AlignmentAllocator<T2, Align2>&) const noexcept {
+        return std::is_same_v<T, T2> && Align == Align2;
+    }
 };
 
 } // namespace Common

src/common/logging/backend.cpp

@@ -6,6 +6,7 @@
 #include <chrono>
 #include <climits>
 #include <exception>
+#include <stop_token>
 #include <thread>
 #include <vector>
 
@@ -205,12 +206,12 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, const char* message) {
+                   const char* function, std::string&& message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, message);
-        message_queue.push(entry);
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
+        message_queue.Push(entry);
     }
 
 private:
@@ -228,36 +229,32 @@ private:
             const auto write_logs = [this, &entry]() {
                 ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
             };
-            while (true) {
-                if (!message_queue.try_pop(entry)) {
-                    continue;
+            while (!stop.stop_requested()) {
+                entry = message_queue.PopWait(stop.get_token());
+                if (entry.filename != nullptr) {
+                    write_logs();
                 }
-                if (entry.final_entry) {
-                    break;
-                }
-                write_logs();
             }
             // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
             // case where a system is repeatedly spamming logs even on close.
             int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.try_pop(entry)) {
+            while (max_logs_to_write-- && message_queue.Pop(entry)) {
                 write_logs();
             }
         });
     }
 
     void StopBackendThread() {
-        Entry stop_entry{};
-        stop_entry.final_entry = true;
-        message_queue.push(stop_entry);
+        stop.request_stop();
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, const char* message) const {
+                      const char* function, std::string&& message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
+
         return {
             .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
             .log_class = log_class,
@@ -265,8 +262,7 @@ private:
             .filename = filename,
             .line_num = line_nr,
             .function = function,
-            .message = message,
-            .final_entry = false,
+            .message = std::move(message),
         };
     }
 
@@ -287,8 +283,9 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
+    std::stop_source stop;
     std::thread backend_thread;
-    MPMCQueue<Entry> message_queue{100000};
+    MPSCQueue<Entry, true> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -314,14 +311,11 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
-        std::string message = fmt::vformat(format, args);
-        auto len = message.size() + 1;
-        char* msg = new char[len];
-        memcpy(msg, message.data(), len);
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function, msg);
+        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
+                                   fmt::vformat(format, args));
     }
 }
 } // namespace Common::Log

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::string_view format, const Args&... args) {
+                   const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/common/logging/log_entry.h

@@ -14,15 +14,14 @@ namespace Common::Log {
  * A log entry. Log entries are store in a structured format to permit more varied output
  * formatting on different frontends, as well as facilitating filtering and aggregation.
  */
-struct Entry final {
+struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class{};
     Level log_level{};
     const char* filename = nullptr;
     unsigned int line_num = 0;
-    const char* function;
-    const char* message;
-    bool final_entry = false;
+    std::string function;
+    std::string message;
 };
 
 } // namespace Common::Log

src/common/settings.h

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
-#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -487,9 +486,9 @@ struct Values {
     // System
     Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
-    std::optional<std::chrono::seconds> custom_rtc;
+    std::optional<s64> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
-    std::chrono::seconds custom_rtc_differential;
+    s64 custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
     RangedSetting<s32> language_index{1, 0, 17, "language_index"};

src/common/threadsafe_queue.h

@@ -1,287 +1,195 @@
-/*
-Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
+// Copyright 2010 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
 
 #pragma once
 
-#include <atomic>
-#include <cassert>
-#include <cstddef> // offsetof
-#include <limits>
-#include <memory>
-#include <new> // std::hardware_destructive_interference_size
-#include <stdexcept>
+// a simple lockless thread-safe,
+// single reader, single writer queue
 
-#ifndef __cpp_aligned_new
-#ifdef _WIN32
-#include <malloc.h> // _aligned_malloc
-#else
-#include <stdlib.h> // posix_memalign
-#endif
-#endif
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+#include <utility>
 
 namespace Common {
-namespace mpmc {
-#ifdef __cpp_lib_hardware_interference_size
-static constexpr size_t hardwareInterferenceSize = std::hardware_destructive_interference_size;
-#else
-static constexpr size_t hardwareInterferenceSize = 64;
-#endif
-
-#if defined(_MSC_VER)
-// Disables "structure was padded due to alignment specifier" warnings.
-#pragma warning(suppress : 4324)
-#endif
-
-#if defined(__cpp_aligned_new)
-template <typename T>
-using AlignedAllocator = std::allocator<T>;
-#else
-template <typename T>
-struct AlignedAllocator {
-    using value_type = T;
-
-    T* allocate(std::size_t n) {
-        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
-            throw std::bad_array_new_length();
-        }
-#ifdef _WIN32
-        auto* p = static_cast<T*>(_aligned_malloc(sizeof(T) * n, alignof(T)));
-        if (p == nullptr) {
-            throw std::bad_alloc();
-        }
-#else
-        T* p;
-        if (posix_memalign(reinterpret_cast<void**>(&p), alignof(T), sizeof(T) * n) != 0) {
-            throw std::bad_alloc();
-        }
-#endif
-        return p;
-    }
-
-    void deallocate(T* p, std::size_t) {
-#ifdef _WIN32
-        _aligned_free(p);
-#else
-        free(p);
-#endif
-    }
-};
-#endif
-
-template <typename T>
-struct Slot {
-    ~Slot() noexcept {
-        if (turn & 1) {
-            destroy();
-        }
-    }
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        new (&storage) T(std::forward<Args>(args)...);
-    }
-
-    void destroy() noexcept {
-        static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
-        reinterpret_cast<T*>(&storage)->~T();
-    }
-
-    T&& move() noexcept {
-        return reinterpret_cast<T&&>(storage);
-    }
-
-    // Align to avoid false sharing between adjacent slots
-    alignas(hardwareInterferenceSize) std::atomic<size_t> turn = {0};
-    typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
-};
-
-template <typename T, typename Allocator = AlignedAllocator<Slot<T>>>
-class Queue {
-private:
-    static_assert(std::is_nothrow_copy_assignable<T>::value ||
-                      std::is_nothrow_move_assignable<T>::value,
-                  "T must be nothrow copy or move assignable");
-
-    static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
-
+template <typename T, bool with_stop_token = false>
+class SPSCQueue {
 public:
-    explicit Queue(const size_t capacity, const Allocator& allocator = Allocator())
-        : capacity_(capacity), allocator_(allocator), head_(0), tail_(0) {
-        if (capacity_ < 1) {
-            throw std::invalid_argument("capacity < 1");
-        }
-        // Allocate one extra slot to prevent false sharing on the last slot
-        slots_ = allocator_.allocate(capacity_ + 1);
-        // Allocators are not required to honor alignment for over-aligned types
-        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
-        // alignment here
-        if (reinterpret_cast<size_t>(slots_) % alignof(Slot<T>) != 0) {
-            allocator_.deallocate(slots_, capacity_ + 1);
-            throw std::bad_alloc();
-        }
-        for (size_t i = 0; i < capacity_; ++i) {
-            new (&slots_[i]) Slot<T>();
-        }
-        static_assert(alignof(Slot<T>) == hardwareInterferenceSize,
-                      "Slot must be aligned to cache line boundary to prevent false sharing");
-        static_assert(sizeof(Slot<T>) % hardwareInterferenceSize == 0,
-                      "Slot size must be a multiple of cache line size to prevent "
-                      "false sharing between adjacent slots");
-        static_assert(sizeof(Queue) % hardwareInterferenceSize == 0,
-                      "Queue size must be a multiple of cache line size to "
-                      "prevent false sharing between adjacent queues");
-        static_assert(offsetof(Queue, tail_) - offsetof(Queue, head_) ==
-                          static_cast<std::ptrdiff_t>(hardwareInterferenceSize),
-                      "head and tail must be a cache line apart to prevent false sharing");
+    SPSCQueue() {
+        write_ptr = read_ptr = new ElementPtr();
+    }
+    ~SPSCQueue() {
+        // this will empty out the whole queue
+        delete read_ptr;
     }
 
-    ~Queue() noexcept {
-        for (size_t i = 0; i < capacity_; ++i) {
-            slots_[i].~Slot();
-        }
-        allocator_.deallocate(slots_, capacity_ + 1);
+    [[nodiscard]] std::size_t Size() const {
+        return size.load();
     }
 
-    // non-copyable and non-movable
-    Queue(const Queue&) = delete;
-    Queue& operator=(const Queue&) = delete;
-
-    template <typename... Args>
-    void emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        auto const head = head_.fetch_add(1);
-        auto& slot = slots_[idx(head)];
-        while (turn(head) * 2 != slot.turn.load(std::memory_order_acquire))
-            ;
-        slot.construct(std::forward<Args>(args)...);
-        slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
+    [[nodiscard]] bool Empty() const {
+        return Size() == 0;
     }
 
-    template <typename... Args>
-    bool try_emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        auto head = head_.load(std::memory_order_acquire);
-        for (;;) {
-            auto& slot = slots_[idx(head)];
-            if (turn(head) * 2 == slot.turn.load(std::memory_order_acquire)) {
-                if (head_.compare_exchange_strong(head, head + 1)) {
-                    slot.construct(std::forward<Args>(args)...);
-                    slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
-                    return true;
-                }
-            } else {
-                auto const prevHead = head;
-                head = head_.load(std::memory_order_acquire);
-                if (head == prevHead) {
-                    return false;
-                }
-            }
+    [[nodiscard]] T& Front() const {
+        return read_ptr->current;
+    }
+
+    template <typename Arg>
+    void Push(Arg&& t) {
+        // create the element, add it to the queue
+        write_ptr->current = std::forward<Arg>(t);
+        // set the next pointer to a new element ptr
+        // then advance the write pointer
+        ElementPtr* new_ptr = new ElementPtr();
+        write_ptr->next.store(new_ptr, std::memory_order_release);
+        write_ptr = new_ptr;
+        ++size;
+
+        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
+        // line before cv.wait
+        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
+        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
+        std::lock_guard lock{cv_mutex};
+        cv.notify_one();
+    }
+
+    void Pop() {
+        --size;
+
+        ElementPtr* tmpptr = read_ptr;
+        // advance the read pointer
+        read_ptr = tmpptr->next.load();
+        // set the next element to nullptr to stop the recursive deletion
+        tmpptr->next.store(nullptr);
+        delete tmpptr; // this also deletes the element
+    }
+
+    bool Pop(T& t) {
+        if (Empty())
+            return false;
+
+        --size;
+
+        ElementPtr* tmpptr = read_ptr;
+        read_ptr = tmpptr->next.load(std::memory_order_acquire);
+        t = std::move(tmpptr->current);
+        tmpptr->next.store(nullptr);
+        delete tmpptr;
+        return true;
+    }
+
+    void Wait() {
+        if (Empty()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, [this] { return !Empty(); });
         }
     }
 
-    void push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible<T>::value,
-                      "T must be nothrow copy constructible");
-        emplace(v);
+    T PopWait() {
+        Wait();
+        T t;
+        Pop(t);
+        return t;
     }
 
-    template <typename P, typename = typename std::enable_if<
-                              std::is_nothrow_constructible<T, P&&>::value>::type>
-    void push(P&& v) noexcept {
-        emplace(std::forward<P>(v));
-    }
-
-    bool try_push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible<T>::value,
-                      "T must be nothrow copy constructible");
-        return try_emplace(v);
-    }
-
-    template <typename P, typename = typename std::enable_if<
-                              std::is_nothrow_constructible<T, P&&>::value>::type>
-    bool try_push(P&& v) noexcept {
-        return try_emplace(std::forward<P>(v));
-    }
-
-    void pop(T& v) noexcept {
-        auto const tail = tail_.fetch_add(1);
-        auto& slot = slots_[idx(tail)];
-        while (turn(tail) * 2 + 1 != slot.turn.load(std::memory_order_acquire))
-            ;
-        v = slot.move();
-        slot.destroy();
-        slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
-    }
-
-    bool try_pop(T& v) noexcept {
-        auto tail = tail_.load(std::memory_order_acquire);
-        for (;;) {
-            auto& slot = slots_[idx(tail)];
-            if (turn(tail) * 2 + 1 == slot.turn.load(std::memory_order_acquire)) {
-                if (tail_.compare_exchange_strong(tail, tail + 1)) {
-                    v = slot.move();
-                    slot.destroy();
-                    slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
-                    return true;
-                }
-            } else {
-                auto const prevTail = tail;
-                tail = tail_.load(std::memory_order_acquire);
-                if (tail == prevTail) {
-                    return false;
-                }
-            }
+    T PopWait(std::stop_token stop_token) {
+        if (Empty()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, stop_token, [this] { return !Empty(); });
         }
+        if (stop_token.stop_requested()) {
+            return T{};
+        }
+        T t;
+        Pop(t);
+        return t;
+    }
+
+    // not thread-safe
+    void Clear() {
+        size.store(0);
+        delete read_ptr;
+        write_ptr = read_ptr = new ElementPtr();
     }
 
 private:
-    constexpr size_t idx(size_t i) const noexcept {
-        return i % capacity_;
-    }
+    // stores a pointer to element
+    // and a pointer to the next ElementPtr
+    class ElementPtr {
+    public:
+        ElementPtr() {}
+        ~ElementPtr() {
+            ElementPtr* next_ptr = next.load();
 
-    constexpr size_t turn(size_t i) const noexcept {
-        return i / capacity_;
-    }
+            if (next_ptr)
+                delete next_ptr;
+        }
 
-private:
-    const size_t capacity_;
-    Slot<T>* slots_;
-#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
-    Allocator allocator_ [[no_unique_address]];
-#else
-    Allocator allocator_;
-#endif
+        T current;
+        std::atomic<ElementPtr*> next{nullptr};
+    };
 
-    // Align to avoid false sharing between head_ and tail_
-    alignas(hardwareInterferenceSize) std::atomic<size_t> head_;
-    alignas(hardwareInterferenceSize) std::atomic<size_t> tail_;
+    ElementPtr* write_ptr;
+    ElementPtr* read_ptr;
+    std::atomic_size_t size{0};
+    std::mutex cv_mutex;
+    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
 };
-} // namespace mpmc
 
-template <typename T, typename Allocator = mpmc::AlignedAllocator<mpmc::Slot<T>>>
-using MPMCQueue = mpmc::Queue<T, Allocator>;
+// a simple thread-safe,
+// single reader, multiple writer queue
 
-} // namespace Common
+template <typename T, bool with_stop_token = false>
+class MPSCQueue {
+public:
+    [[nodiscard]] std::size_t Size() const {
+        return spsc_queue.Size();
+    }
+
+    [[nodiscard]] bool Empty() const {
+        return spsc_queue.Empty();
+    }
+
+    [[nodiscard]] T& Front() const {
+        return spsc_queue.Front();
+    }
+
+    template <typename Arg>
+    void Push(Arg&& t) {
+        std::lock_guard lock{write_lock};
+        spsc_queue.Push(t);
+    }
+
+    void Pop() {
+        return spsc_queue.Pop();
+    }
+
+    bool Pop(T& t) {
+        return spsc_queue.Pop(t);
+    }
+
+    void Wait() {
+        spsc_queue.Wait();
+    }
+
+    T PopWait() {
+        return spsc_queue.PopWait();
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        return spsc_queue.PopWait(stop_token);
+    }
+
+    // not thread-safe
+    void Clear() {
+        spsc_queue.Clear();
+    }
+
+private:
+    SPSCQueue<T, with_stop_token> spsc_queue;
+    std::mutex write_lock;
+};
+} // namespace Common

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -263,7 +263,7 @@ void ARM_Dynarmic_64::Run() {
 }
 
 void ARM_Dynarmic_64::Step() {
-    cb->InterpreterFallback(jit->GetPC(), 1);
+    jit->Step();
 }
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,

src/core/core.cpp

@@ -196,8 +196,9 @@ struct System::Impl {
         cpu_manager.Initialize();
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
-            std::chrono::system_clock::now().time_since_epoch());
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
         Settings::values.custom_rtc_differential =
             Settings::values.custom_rtc.value_or(current_time) - current_time;
 

src/core/file_sys/control_metadata.cpp

@@ -9,7 +9,7 @@
 
 namespace FileSys {
 
-const std::array<const char*, 15> LANGUAGE_NAMES{{
+const std::array<const char*, 16> LANGUAGE_NAMES{{
     "AmericanEnglish",
     "BritishEnglish",
     "Japanese",
@@ -25,6 +25,7 @@ const std::array<const char*, 15> LANGUAGE_NAMES{{
     "Korean",
     "Taiwanese",
     "Chinese",
+    "BrazilianPortuguese",
 }};
 
 std::string LanguageEntry::GetApplicationName() const {

src/core/file_sys/control_metadata.h

@@ -88,11 +88,12 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
+    BrazilianPortuguese = 15,
 
     Default = 255,
 };
 
-extern const std::array<const char*, 15> LANGUAGE_NAMES;
+extern const std::array<const char*, 16> LANGUAGE_NAMES;
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/hle/kernel/k_scheduler.h

@@ -49,6 +49,11 @@ public:
     /// Gets the current running thread
     [[nodiscard]] KThread* GetCurrentThread() const;
 
+    /// Gets the idle thread
+    [[nodiscard]] KThread* GetIdleThread() const {
+        return idle_thread;
+    }
+
     /// Returns true if the scheduler is idle
     [[nodiscard]] bool IsIdle() const {
         return GetCurrentThread() == idle_thread;

src/core/hle/kernel/svc.cpp

@@ -886,7 +886,24 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
         *result = out_ticks;
         return ResultSuccess;
     }
+    case GetInfoType::IdleTickCount: {
+        if (handle == 0) {
+            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
+                      static_cast<Handle>(handle));
+            return ResultInvalidHandle;
+        }
 
+        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id != system.CurrentCoreIndex()) {
+            LOG_ERROR(Kernel_SVC, "Core is not the current core, got {}", info_sub_id);
+            return ResultInvalidCombination;
+        }
+
+        const auto& scheduler = *system.Kernel().CurrentScheduler();
+        const auto* const idle_thread = scheduler.GetIdleThread();
+
+        *result = idle_thread->GetCpuTime();
+        return ResultSuccess;
+    }
     default:
         LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
         return ResultInvalidEnumValue;

src/core/hle/result.h

@@ -206,7 +206,7 @@ public:
         return result;
     }
 
-    ResultVal(const ResultVal& o) : result_code(o.result_code) {
+    ResultVal(const ResultVal& o) noexcept : result_code(o.result_code) {
         if (!o.empty()) {
             new (&object) T(o.object);
         }
@@ -224,7 +224,7 @@ public:
         }
     }
 
-    ResultVal& operator=(const ResultVal& o) {
+    ResultVal& operator=(const ResultVal& o) noexcept {
         if (this == &o) {
             return *this;
         }
@@ -244,6 +244,26 @@ public:
         return *this;
     }
 
+    ResultVal& operator=(ResultVal&& o) noexcept {
+        if (this == &o) {
+            return *this;
+        }
+        if (!empty()) {
+            if (!o.empty()) {
+                object = std::move(o.object);
+            } else {
+                object.~T();
+            }
+        } else {
+            if (!o.empty()) {
+                new (&object) T(std::move(o.object));
+            }
+        }
+        result_code = o.result_code;
+
+        return *this;
+    }
+
     /**
      * Replaces the current result with a new constructed result value in-place. The code must not
      * be an error code.
@@ -329,8 +349,8 @@ template <typename T, typename... Args>
  * copy or move constructing.
  */
 template <typename Arg>
-[[nodiscard]] ResultVal<std::remove_reference_t<Arg>> MakeResult(Arg&& arg) {
-    return ResultVal<std::remove_reference_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
+[[nodiscard]] ResultVal<std::remove_cvref_t<Arg>> MakeResult(Arg&& arg) {
+    return ResultVal<std::remove_cvref_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
 }
 
 /**

src/core/hle/service/ns/language.cpp

@@ -277,6 +277,25 @@ constexpr ApplicationLanguagePriorityList priority_list_simplified_chinese = {{
     ApplicationLanguage::Korean,
 }};
 
+constexpr ApplicationLanguagePriorityList priority_list_brazilian_portuguese = {{
+    ApplicationLanguage::BrazilianPortuguese,
+    ApplicationLanguage::Portuguese,
+    ApplicationLanguage::LatinAmericanSpanish,
+    ApplicationLanguage::AmericanEnglish,
+    ApplicationLanguage::BritishEnglish,
+    ApplicationLanguage::Japanese,
+    ApplicationLanguage::French,
+    ApplicationLanguage::German,
+    ApplicationLanguage::Spanish,
+    ApplicationLanguage::Italian,
+    ApplicationLanguage::Dutch,
+    ApplicationLanguage::CanadianFrench,
+    ApplicationLanguage::Russian,
+    ApplicationLanguage::Korean,
+    ApplicationLanguage::SimplifiedChinese,
+    ApplicationLanguage::TraditionalChinese,
+}};
+
 const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
     const ApplicationLanguage lang) {
     switch (lang) {
@@ -310,6 +329,8 @@ const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
         return &priority_list_traditional_chinese;
     case ApplicationLanguage::SimplifiedChinese:
         return &priority_list_simplified_chinese;
+    case ApplicationLanguage::BrazilianPortuguese:
+        return &priority_list_brazilian_portuguese;
     default:
         return nullptr;
     }
@@ -339,7 +360,6 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::FR_CA:
         return ApplicationLanguage::CanadianFrench;
     case Set::LanguageCode::PT:
-    case Set::LanguageCode::PT_BR:
         return ApplicationLanguage::Portuguese;
     case Set::LanguageCode::RU:
         return ApplicationLanguage::Russian;
@@ -351,6 +371,8 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::ZH_CN:
     case Set::LanguageCode::ZH_HANS:
         return ApplicationLanguage::SimplifiedChinese;
+    case Set::LanguageCode::PT_BR:
+        return ApplicationLanguage::BrazilianPortuguese;
     default:
         return std::nullopt;
     }
@@ -388,6 +410,8 @@ std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage
         return Set::LanguageCode::ZH_HANT;
     case ApplicationLanguage::SimplifiedChinese:
         return Set::LanguageCode::ZH_HANS;
+    case ApplicationLanguage::BrazilianPortuguese:
+        return Set::LanguageCode::PT_BR;
     default:
         return std::nullopt;
     }

src/core/hle/service/ns/language.h

@@ -30,6 +30,7 @@ enum class ApplicationLanguage : u8 {
     Korean,
     TraditionalChinese,
     SimplifiedChinese,
+    BrazilianPortuguese,
     Count
 };
 using ApplicationLanguagePriorityList =

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -69,8 +69,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     std::vector<Reloc> relocs(params.relocation_count);
     std::vector<u32> reloc_shifts(params.relocation_count);
     std::vector<SyncptIncr> syncpt_increments(params.syncpoint_count);
-    std::vector<SyncptIncr> wait_checks(params.syncpoint_count);
-    std::vector<Fence> fences(params.fence_count);
+    std::vector<u32> fence_thresholds(params.fence_count);
 
     // Slice input into their respective buffers
     std::size_t offset = sizeof(IoctlSubmit);
@@ -78,15 +77,13 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += SliceVectors(input, relocs, params.relocation_count, offset);
     offset += SliceVectors(input, reloc_shifts, params.relocation_count, offset);
     offset += SliceVectors(input, syncpt_increments, params.syncpoint_count, offset);
-    offset += SliceVectors(input, wait_checks, params.syncpoint_count, offset);
-    offset += SliceVectors(input, fences, params.fence_count, offset);
+    offset += SliceVectors(input, fence_thresholds, params.fence_count, offset);
 
     auto& gpu = system.GPU();
     if (gpu.UseNvdec()) {
         for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
             const SyncptIncr& syncpt_incr = syncpt_increments[i];
-            fences[i].id = syncpt_incr.id;
-            fences[i].value =
+            fence_thresholds[i] =
                 syncpoint_manager.IncreaseSyncpoint(syncpt_incr.id, syncpt_incr.increments);
         }
     }
@@ -98,11 +95,6 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
                                   cmdlist.size() * sizeof(u32));
         gpu.PushCommandBuffer(cmdlist);
     }
-    if (gpu.UseNvdec()) {
-        fences[0].value = syncpoint_manager.IncreaseSyncpoint(fences[0].id, 1);
-        Tegra::ChCommandHeaderList cmdlist{{(4 << 28) | fences[0].id}};
-        gpu.PushCommandBuffer(cmdlist);
-    }
     std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back
     offset = sizeof(IoctlSubmit);
@@ -110,8 +102,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += WriteVectors(output, relocs, offset);
     offset += WriteVectors(output, reloc_shifts, offset);
     offset += WriteVectors(output, syncpt_increments, offset);
-    offset += WriteVectors(output, wait_checks, offset);
-    offset += WriteVectors(output, fences, offset);
+    offset += WriteVectors(output, fence_thresholds, offset);
 
     return NvResult::Success;
 }

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -56,19 +56,16 @@ protected:
         s32 target{};
         s32 target_offset{};
     };
-    static_assert(sizeof(Reloc) == 0x10, "CommandBuffer has incorrect size");
+    static_assert(sizeof(Reloc) == 0x10, "Reloc has incorrect size");
 
     struct SyncptIncr {
         u32 id{};
         u32 increments{};
+        u32 unk0{};
+        u32 unk1{};
+        u32 unk2{};
     };
-    static_assert(sizeof(SyncptIncr) == 0x8, "CommandBuffer has incorrect size");
-
-    struct Fence {
-        u32 id{};
-        u32 value{};
-    };
-    static_assert(sizeof(Fence) == 0x8, "CommandBuffer has incorrect size");
+    static_assert(sizeof(SyncptIncr) == 0x14, "SyncptIncr has incorrect size");
 
     struct IoctlGetSyncpoint {
         // Input

src/core/hle/service/time/time_manager.cpp

@@ -13,18 +13,19 @@
 #include "core/hle/service/time/time_manager.h"
 
 namespace Service::Time {
-
+namespace {
 constexpr Clock::TimeSpanType standard_network_clock_accuracy{0x0009356907420000ULL};
 
-static std::chrono::seconds GetSecondsSinceEpoch() {
-    return std::chrono::duration_cast<std::chrono::seconds>(
-               std::chrono::system_clock::now().time_since_epoch()) +
+s64 GetSecondsSinceEpoch() {
+    const auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch();
+    return std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch).count() +
            Settings::values.custom_rtc_differential;
 }
 
-static s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch().count() + TimeManager::GetExternalTimeZoneOffset();
+s64 GetExternalRtcValue() {
+    return GetSecondsSinceEpoch() + TimeManager::GetExternalTimeZoneOffset();
 }
+} // Anonymous namespace
 
 struct TimeManager::Impl final {
     explicit Impl(Core::System& system)

src/input_common/gcadapter/gc_adapter.cpp

@@ -170,7 +170,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
 
     if (pads[port].buttons != 0) {
         pad_status.button = pads[port].last_button;
-        pad_queue.push(pad_status);
+        pad_queue.Push(pad_status);
     }
 
     // Accounting for a threshold here to ensure an intentional press
@@ -181,7 +181,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
             pad_status.axis = static_cast<PadAxes>(i);
             pad_status.axis_value = value;
             pad_status.axis_threshold = axis_threshold;
-            pad_queue.push(pad_status);
+            pad_queue.Push(pad_status);
         }
     }
 }
@@ -478,18 +478,20 @@ bool Adapter::DeviceConnected(std::size_t port) const {
 }
 
 void Adapter::BeginConfiguration() {
+    pad_queue.Clear();
     configuring = true;
 }
 
 void Adapter::EndConfiguration() {
+    pad_queue.Clear();
     configuring = false;
 }
 
-Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() {
+Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
+const Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
     return pad_queue;
 }
 

src/input_common/gcadapter/gc_adapter.h

@@ -85,8 +85,8 @@ public:
     void BeginConfiguration();
     void EndConfiguration();
 
-    Common::MPMCQueue<GCPadStatus>& GetPadQueue();
-    const Common::MPMCQueue<GCPadStatus>& GetPadQueue() const;
+    Common::SPSCQueue<GCPadStatus>& GetPadQueue();
+    const Common::SPSCQueue<GCPadStatus>& GetPadQueue() const;
 
     GCController& GetPadState(std::size_t port);
     const GCController& GetPadState(std::size_t port) const;
@@ -145,7 +145,7 @@ private:
 
     libusb_device_handle* usb_adapter_handle = nullptr;
     std::array<GCController, 4> pads;
-    Common::MPMCQueue<GCPadStatus> pad_queue{1024};
+    Common::SPSCQueue<GCPadStatus> pad_queue;
 
     std::thread adapter_input_thread;
     std::thread adapter_scan_thread;

src/input_common/gcadapter/gc_poller.cpp

@@ -103,7 +103,7 @@ Common::ParamPackage GCButtonFactory::GetNextInput() const {
     Common::ParamPackage params;
     GCAdapter::GCPadStatus pad;
     auto& queue = adapter->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         params.Set("engine", "gcpad");
         params.Set("port", static_cast<s32>(pad.port));
@@ -263,7 +263,7 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
     GCAdapter::GCPadStatus pad;
     Common::ParamPackage params;
     auto& queue = adapter->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         if (pad.button != GCAdapter::PadButton::Undefined) {
             params.Set("engine", "gcpad");
             params.Set("port", static_cast<s32>(pad.port));

src/input_common/mouse/mouse_input.cpp

@@ -52,7 +52,7 @@ void Mouse::UpdateYuzuSettings() {
         return;
     }
 
-    mouse_queue.push(MouseStatus{
+    mouse_queue.Push(MouseStatus{
         .button = last_button,
     });
 }
@@ -153,6 +153,7 @@ void Mouse::ReleaseAllButtons() {
 void Mouse::BeginConfiguration() {
     buttons = 0;
     last_button = MouseButton::Undefined;
+    mouse_queue.Clear();
     configuring = true;
 }
 
@@ -164,6 +165,7 @@ void Mouse::EndConfiguration() {
         info.data.axis = {0, 0};
     }
     last_button = MouseButton::Undefined;
+    mouse_queue.Clear();
     configuring = false;
 }
 
@@ -203,11 +205,11 @@ bool Mouse::UnlockButton(std::size_t button_) {
     return button_state;
 }
 
-Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() {
+Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() {
     return mouse_queue;
 }
 
-const Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
+const Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
     return mouse_queue;
 }
 

src/input_common/mouse/mouse_input.h

@@ -79,8 +79,8 @@ public:
     [[nodiscard]] bool ToggleButton(std::size_t button_);
     [[nodiscard]] bool UnlockButton(std::size_t button_);
 
-    [[nodiscard]] Common::MPMCQueue<MouseStatus>& GetMouseQueue();
-    [[nodiscard]] const Common::MPMCQueue<MouseStatus>& GetMouseQueue() const;
+    [[nodiscard]] Common::SPSCQueue<MouseStatus>& GetMouseQueue();
+    [[nodiscard]] const Common::SPSCQueue<MouseStatus>& GetMouseQueue() const;
 
     [[nodiscard]] MouseData& GetMouseState(std::size_t button);
     [[nodiscard]] const MouseData& GetMouseState(std::size_t button) const;
@@ -109,7 +109,7 @@ private:
     std::jthread update_thread;
     MouseButton last_button{MouseButton::Undefined};
     std::array<MouseInfo, 7> mouse_info;
-    Common::MPMCQueue<MouseStatus> mouse_queue{1024};
+    Common::SPSCQueue<MouseStatus> mouse_queue;
     bool configuring{false};
     int mouse_panning_timout{};
 };

src/input_common/mouse/mouse_poller.cpp

@@ -52,7 +52,7 @@ Common::ParamPackage MouseButtonFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -184,7 +184,7 @@ Common::ParamPackage MouseAnalogFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -227,7 +227,7 @@ Common::ParamPackage MouseMotionFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -275,7 +275,7 @@ Common::ParamPackage MouseTouchFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");

src/input_common/sdl/sdl_impl.cpp

@@ -46,7 +46,7 @@ static int SDLEventWatcher(void* user_data, SDL_Event* event) {
 
     // Don't handle the event if we are configuring
     if (sdl_state->polling) {
-        sdl_state->event_queue.push(*event);
+        sdl_state->event_queue.Push(*event);
     } else {
         sdl_state->HandleGameControllerEvent(*event);
     }
@@ -1460,6 +1460,7 @@ public:
     explicit SDLPoller(SDLState& state_) : state(state_) {}
 
     void Start([[maybe_unused]] const std::string& device_id) override {
+        state.event_queue.Clear();
         state.polling = true;
     }
 
@@ -1477,7 +1478,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1549,7 +1550,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1591,7 +1592,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             if (event.type != SDL_JOYAXISMOTION) {
                 // Check for a button press
                 auto button_press = button_poller.FromEvent(event);

src/input_common/sdl/sdl_impl.h

@@ -59,7 +59,7 @@ public:
 
     /// Used by the Pollers during config
     std::atomic<bool> polling = false;
-    Common::MPMCQueue<SDL_Event> event_queue{1024};
+    Common::SPSCQueue<SDL_Event> event_queue;
 
     std::vector<Common::ParamPackage> GetInputDevices() override;
 

src/input_common/udp/client.cpp

@@ -338,7 +338,7 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
                   gyro[0], gyro[1], gyro[2], acc[0], acc[1], acc[2]);
     }
     UDPPadStatus pad{
-        .host = clients[client].host.c_str(),
+        .host = clients[client].host,
         .port = clients[client].port,
         .pad_index = pad_index,
     };
@@ -346,12 +346,12 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
         if (gyro[i] > 5.0f || gyro[i] < -5.0f) {
             pad.motion = static_cast<PadMotion>(i);
             pad.motion_value = gyro[i];
-            pad_queue.push(pad);
+            pad_queue.Push(pad);
         }
         if (acc[i] > 1.75f || acc[i] < -1.75f) {
             pad.motion = static_cast<PadMotion>(i + 3);
             pad.motion_value = acc[i];
-            pad_queue.push(pad);
+            pad_queue.Push(pad);
         }
     }
 }
@@ -401,10 +401,12 @@ void Client::UpdateTouchInput(Response::TouchPad& touch_pad, std::size_t client,
 }
 
 void Client::BeginConfiguration() {
+    pad_queue.Clear();
     configuring = true;
 }
 
 void Client::EndConfiguration() {
+    pad_queue.Clear();
     configuring = false;
 }
 
@@ -432,11 +434,11 @@ const Input::TouchStatus& Client::GetTouchState() const {
     return touch_status;
 }
 
-Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() {
+Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() const {
+const Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() const {
     return pad_queue;
 }
 
@@ -469,46 +471,42 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
     std::function<void(u16, u16, u16, u16)> data_callback) {
 
     std::thread([=, this] {
-        constexpr u16 CALIBRATION_THRESHOLD = 100;
-
-        u16 min_x{UINT16_MAX};
-        u16 min_y{UINT16_MAX};
-        u16 max_x{};
-        u16 max_y{};
-
         Status current_status{Status::Initialized};
-        SocketCallback callback{[](Response::Version) {}, [](Response::PortInfo) {},
-                                [&](Response::PadData data) {
-                                    if (current_status == Status::Initialized) {
-                                        // Receiving data means the communication is ready now
-                                        current_status = Status::Ready;
-                                        status_callback(current_status);
-                                    }
-                                    if (data.touch[0].is_active == 0) {
-                                        return;
-                                    }
-                                    LOG_DEBUG(Input, "Current touch: {} {}", data.touch[0].x,
-                                              data.touch[0].y);
-                                    min_x = std::min(min_x, static_cast<u16>(data.touch[0].x));
-                                    min_y = std::min(min_y, static_cast<u16>(data.touch[0].y));
-                                    if (current_status == Status::Ready) {
-                                        // First touch - min data (min_x/min_y)
-                                        current_status = Status::Stage1Completed;
-                                        status_callback(current_status);
-                                    }
-                                    if (data.touch[0].x - min_x > CALIBRATION_THRESHOLD &&
-                                        data.touch[0].y - min_y > CALIBRATION_THRESHOLD) {
-                                        // Set the current position as max value and finishes
-                                        // configuration
-                                        max_x = data.touch[0].x;
-                                        max_y = data.touch[0].y;
-                                        current_status = Status::Completed;
-                                        data_callback(min_x, min_y, max_x, max_y);
-                                        status_callback(current_status);
+        SocketCallback callback{
+            [](Response::Version) {}, [](Response::PortInfo) {},
+            [&](Response::PadData data) {
+                static constexpr u16 CALIBRATION_THRESHOLD = 100;
+                static constexpr u16 MAX_VALUE = UINT16_MAX;
 
-                                        complete_event.Set();
-                                    }
-                                }};
+                if (current_status == Status::Initialized) {
+                    // Receiving data means the communication is ready now
+                    current_status = Status::Ready;
+                    status_callback(current_status);
+                }
+                const auto& touchpad_0 = data.touch[0];
+                if (touchpad_0.is_active == 0) {
+                    return;
+                }
+                LOG_DEBUG(Input, "Current touch: {} {}", touchpad_0.x, touchpad_0.y);
+                const u16 min_x = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.x));
+                const u16 min_y = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.y));
+                if (current_status == Status::Ready) {
+                    // First touch - min data (min_x/min_y)
+                    current_status = Status::Stage1Completed;
+                    status_callback(current_status);
+                }
+                if (touchpad_0.x - min_x > CALIBRATION_THRESHOLD &&
+                    touchpad_0.y - min_y > CALIBRATION_THRESHOLD) {
+                    // Set the current position as max value and finishes configuration
+                    const u16 max_x = touchpad_0.x;
+                    const u16 max_y = touchpad_0.y;
+                    current_status = Status::Completed;
+                    data_callback(min_x, min_y, max_x, max_y);
+                    status_callback(current_status);
+
+                    complete_event.Set();
+                }
+            }};
         Socket socket{host, port, std::move(callback)};
         std::thread worker_thread{SocketLoop, &socket};
         complete_event.Wait();

src/input_common/udp/client.h

@@ -46,7 +46,7 @@ enum class PadTouch {
 };
 
 struct UDPPadStatus {
-    const char* host{"127.0.0.1"};
+    std::string host{"127.0.0.1"};
     u16 port{26760};
     std::size_t pad_index{};
     PadMotion motion{PadMotion::Undefined};
@@ -85,8 +85,8 @@ public:
     bool DeviceConnected(std::size_t pad) const;
     void ReloadSockets();
 
-    Common::MPMCQueue<UDPPadStatus>& GetPadQueue();
-    const Common::MPMCQueue<UDPPadStatus>& GetPadQueue() const;
+    Common::SPSCQueue<UDPPadStatus>& GetPadQueue();
+    const Common::SPSCQueue<UDPPadStatus>& GetPadQueue() const;
 
     DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad);
     const DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad) const;
@@ -146,7 +146,7 @@ private:
     static constexpr std::size_t MAX_TOUCH_FINGERS = MAX_UDP_CLIENTS * 2;
     std::array<PadData, MAX_UDP_CLIENTS * PADS_PER_CLIENT> pads{};
     std::array<ClientConnection, MAX_UDP_CLIENTS> clients{};
-    Common::MPMCQueue<UDPPadStatus> pad_queue{1024};
+    Common::SPSCQueue<UDPPadStatus> pad_queue{};
     Input::TouchStatus touch_status{};
     std::array<std::size_t, MAX_TOUCH_FINGERS> finger_id{};
 };

src/input_common/udp/udp.cpp

@@ -59,7 +59,7 @@ Common::ParamPackage UDPMotionFactory::GetNextInput() {
     Common::ParamPackage params;
     CemuhookUDP::UDPPadStatus pad;
     auto& queue = client->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         if (pad.motion == CemuhookUDP::PadMotion::Undefined || std::abs(pad.motion_value) < 1) {
             continue;
         }

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -355,11 +355,22 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                   Id coords, Id dref, Id bias_lc, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0, bias_lc,
-                                 offset);
-    return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
-                &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
-                Texture(ctx, info, index), coords, dref, operands.MaskOptional(), operands.Span());
+    if (ctx.stage == Stage::Fragment) {
+        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
+                                     bias_lc, offset);
+        return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
+                    &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
+                    Texture(ctx, info, index), coords, dref, operands.MaskOptional(),
+                    operands.Span());
+    } else {
+        // Implicit lods in compute behave on hardware as if sampling from LOD 0.
+        // This check is to ensure all drivers behave this way.
+        const Id lod{ctx.Const(0.0f)};
+        const ImageOperands operands(ctx, false, true, false, lod, offset);
+        return Emit(&EmitContext::OpImageSparseSampleDrefExplicitLod,
+                    &EmitContext::OpImageSampleDrefExplicitLod, ctx, inst, ctx.F32[1],
+                    Texture(ctx, info, index), coords, dref, operands.Mask(), operands.Span());
+    }
 }
 
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -492,7 +492,7 @@ void TexturePass(Environment& env, IR::Program& program) {
             const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
             IR::IREmitter ir{*texture_inst.block, insert_point};
             const IR::U32 shift{ir.Imm32(std::countr_zero(DESCRIPTOR_SIZE))};
-            inst->SetArg(0, ir.SMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
+            inst->SetArg(0, ir.UMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
                                     ir.Imm32(DESCRIPTOR_SIZE - 1)));
         } else {
             inst->SetArg(0, IR::Value{});

src/video_core/dirty_flags.h

@@ -38,6 +38,9 @@ enum : u8 {
 
     Shaders,
 
+    // Special entries
+    DepthBiasGlobal,
+
     LastCommonEntry,
 };
 

src/video_core/gpu_thread.cpp

@@ -32,8 +32,7 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
     VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
 
     while (!stop_token.stop_requested()) {
-        CommandDataContainer next;
-        state.queue.pop(next);
+        CommandDataContainer next = state.queue.PopWait(stop_token);
         if (stop_token.stop_requested()) {
             break;
         }
@@ -120,7 +119,7 @@ u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
 
     std::unique_lock lk(state.write_lock);
     const u64 fence{++state.last_fence};
-    state.queue.push(CommandDataContainer(std::move(command_data), fence, block));
+    state.queue.Push(CommandDataContainer(std::move(command_data), fence, block));
 
     if (block) {
         state.cv.wait(lk, thread.get_stop_token(), [this, fence] {

src/video_core/gpu_thread.h

@@ -97,9 +97,9 @@ struct CommandDataContainer {
 
 /// Struct used to synchronize the GPU thread
 struct SynchState final {
-    using CommandQueue = Common::MPMCQueue<CommandDataContainer>;
+    using CommandQueue = Common::SPSCQueue<CommandDataContainer, true>;
     std::mutex write_lock;
-    CommandQueue queue{100000};
+    CommandQueue queue;
     u64 last_fence{};
     std::atomic<u64> signaled_fence{};
     std::condition_variable_any cv;

src/video_core/renderer_opengl/gl_device.cpp

@@ -10,6 +10,7 @@
 #include <limits>
 #include <optional>
 #include <span>
+#include <stdexcept>
 #include <vector>
 
 #include <glad/glad.h>
@@ -180,6 +181,21 @@ Device::Device() {
         LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
         shader_backend = Settings::ShaderBackend::GLSL;
     }
+
+    if (shader_backend == Settings::ShaderBackend::GLSL && is_nvidia &&
+        !Settings::values.renderer_debug) {
+        const std::string_view driver_version = version.substr(13);
+        const int version_major =
+            std::atoi(driver_version.substr(0, driver_version.find(".")).data());
+
+        if (version_major >= 495) {
+            LOG_WARNING(Render_OpenGL, "NVIDIA drivers 495 and later causes significant problems "
+                                       "with yuzu. Forcing GLASM as a mitigation.");
+            shader_backend = Settings::ShaderBackend::GLASM;
+            use_assembly_shaders = true;
+        }
+    }
+
     // Blocks AMD and Intel OpenGL drivers on Windows from using asynchronous shader compilation.
     use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue() &&
                                !(is_amd || (is_intel && !is_linux));

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -627,9 +627,21 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchDepthBias()) {
         return;
     }
-    scheduler.Record([constant = regs.polygon_offset_units, clamp = regs.polygon_offset_clamp,
+    float units = regs.polygon_offset_units / 2.0f;
+    const bool is_d24 = regs.zeta.format == Tegra::DepthFormat::S8_UINT_Z24_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24X8_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24S8_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24C8_UNORM;
+    if (is_d24 && !device.SupportsD24DepthBuffer()) {
+        // the base formulas can be obtained from here:
+        //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
+        const double rescale_factor =
+            static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
+        units = static_cast<float>(static_cast<double>(units) * rescale_factor);
+    }
+    scheduler.Record([constant = units, clamp = regs.polygon_offset_clamp,
                       factor = regs.polygon_offset_factor](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthBias(constant, clamp, factor / 2.0f);
+        cmdbuf.SetDepthBias(constant, clamp, factor);
     });
 }
 

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -54,6 +54,7 @@ void SetupDirtyViewports(Tables& tables) {
     FillBlock(tables[0], OFF(viewport_transform), NUM(viewport_transform), Viewports);
     FillBlock(tables[0], OFF(viewports), NUM(viewports), Viewports);
     tables[0][OFF(viewport_transform_enabled)] = Viewports;
+    tables[1][OFF(screen_y_control)] = Viewports;
 }
 
 void SetupDirtyScissors(Tables& tables) {

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -79,7 +79,8 @@ public:
     }
 
     bool TouchDepthBias() {
-        return Exchange(Dirty::DepthBias, false);
+        return Exchange(Dirty::DepthBias, false) ||
+               Exchange(VideoCommon::Dirty::DepthBiasGlobal, false);
     }
 
     bool TouchBlendConstants() {

src/video_core/texture_cache/texture_cache.h

@@ -221,6 +221,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
     }
     const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
+
     PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
 
     for (size_t index = 0; index < NUM_RT; ++index) {
@@ -230,6 +231,8 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         maxwell3d.regs.render_area.width,
         maxwell3d.regs.render_area.height,
     };
+
+    flags[Dirty::DepthBiasGlobal] = true;
 }
 
 template <class P>

src/video_core/vulkan_common/vulkan_device.cpp

@@ -623,6 +623,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         is_float16_supported = false;
     }
 
+    supports_d24_depth =
+        IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
+                          VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
+
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);
 }

src/video_core/vulkan_common/vulkan_device.h

@@ -332,6 +332,10 @@ public:
         return sets_per_pool;
     }
 
+    bool SupportsD24DepthBuffer() const {
+        return supports_d24_depth;
+    }
+
 private:
     /// Checks if the physical device is suitable.
     void CheckSuitability(bool requires_swapchain) const;
@@ -425,6 +429,7 @@ private:
     bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
     bool has_renderdoc{};                   ///< Has RenderDoc attached
     bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
+    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
 
     // Telemetry parameters
     std::string vendor_name;                       ///< Device's driver name.

src/yuzu/CMakeLists.txt

@@ -299,6 +299,11 @@ if (YUZU_USE_BUNDLED_QT)
     copy_yuzu_Qt5_deps(yuzu)
 endif()
 
+if (ENABLE_SDL2)
+    target_link_libraries(yuzu PRIVATE SDL2)
+    target_compile_definitions(yuzu PRIVATE HAVE_SDL2)
+endif()
+
 if (MSVC)
     include(CopyYuzuSDLDeps)
     include(CopyYuzuFFmpegDeps)

src/yuzu/configuration/config.cpp

@@ -918,8 +918,7 @@ void Config::ReadSystemValues() {
         const auto custom_rtc_enabled =
             ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
         if (custom_rtc_enabled) {
-            Settings::values.custom_rtc =
-                std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
+            Settings::values.custom_rtc = ReadSetting(QStringLiteral("custom_rtc"), 0).toLongLong();
         } else {
             Settings::values.custom_rtc = std::nullopt;
         }
@@ -1450,9 +1449,7 @@ void Config::SaveSystemValues() {
         WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
                      false);
         WriteSetting(QStringLiteral("custom_rtc"),
-                     QVariant::fromValue<long long>(
-                         Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
-                     0);
+                     QVariant::fromValue<long long>(Settings::values.custom_rtc.value_or(0)), 0);
     }
 
     WriteGlobalSetting(Settings::values.sound_index);

src/yuzu/configuration/configure_dialog.cpp

@@ -81,8 +81,11 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     SetConfiguration();
     PopulateSelectionList();
 
-    connect(ui->tabWidget, &QTabWidget::currentChanged, this,
-            [this]() { debug_tab_tab->SetCurrentIndex(0); });
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this, [this](int index) {
+        if (index != -1) {
+            debug_tab_tab->SetCurrentIndex(0);
+        }
+    });
     connect(ui_tab.get(), &ConfigureUi::LanguageChanged, this, &ConfigureDialog::OnLanguageChanged);
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);

src/yuzu/configuration/configure_per_game.cpp

@@ -66,7 +66,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id, const std::str
     ui->tabWidget->addTab(system_tab.get(), tr("System"));
     ui->tabWidget->addTab(cpu_tab.get(), tr("CPU"));
     ui->tabWidget->addTab(graphics_tab.get(), tr("Graphics"));
-    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("GraphicsAdvanced"));
+    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("Adv. Graphics"));
     ui->tabWidget->addTab(audio_tab.get(), tr("Audio"));
 
     setFocusPolicy(Qt::ClickFocus);

src/yuzu/configuration/configure_per_game.ui

@@ -2,14 +2,6 @@
 <ui version="4.0">
  <class>ConfigurePerGame</class>
  <widget class="QDialog" name="ConfigurePerGame">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>900</width>
-    <height>630</height>
-   </rect>
-  </property>
   <property name="minimumSize">
    <size>
     <width>900</width>

src/yuzu/configuration/configure_system.cpp

@@ -65,8 +65,7 @@ void ConfigureSystem::SetConfiguration() {
         QStringLiteral("%1")
             .arg(Settings::values.rng_seed.GetValue().value_or(0), 8, 16, QLatin1Char{'0'})
             .toUpper();
-    const auto rtc_time = Settings::values.custom_rtc.value_or(
-        std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
+    const auto rtc_time = Settings::values.custom_rtc.value_or(QDateTime::currentSecsSinceEpoch());
 
     ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
     ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
@@ -75,7 +74,7 @@ void ConfigureSystem::SetConfiguration() {
 
     ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.has_value());
     ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.has_value());
-    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time));
 
     if (Settings::IsConfiguringGlobal()) {
         ui->combo_language->setCurrentIndex(Settings::values.language_index.GetValue());
@@ -108,10 +107,9 @@ void ConfigureSystem::ApplyConfiguration() {
     // to allow in-game time to be fast forwarded
     if (Settings::IsConfiguringGlobal()) {
         if (ui->custom_rtc_checkbox->isChecked()) {
-            Settings::values.custom_rtc =
-                std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
+            Settings::values.custom_rtc = ui->custom_rtc_edit->dateTime().toSecsSinceEpoch();
             if (system.IsPoweredOn()) {
-                const s64 posix_time{Settings::values.custom_rtc->count() +
+                const s64 posix_time{*Settings::values.custom_rtc +
                                      Service::Time::TimeManager::GetExternalTimeZoneOffset()};
                 system.GetTimeManager().UpdateLocalSystemClockTime(posix_time);
             }

src/yuzu/configuration/configure_tas.ui

@@ -14,14 +14,14 @@
         <item row="0" column="0" colspan="4">
          <widget class="QLabel" name="label_1">
           <property name="text">
-           <string>Reads controller input from scripts in the same format as TAS-nx scripts.&lt;br/&gt;For a more detailed explanation please consult the FAQ on the yuzu website.</string>
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Reads controller input from scripts in the same format as TAS-nx scripts.&lt;br/&gt;For a more detailed explanation, please consult the &lt;a href=&quot;https://yuzu-emu.org/help/feature/tas/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#039be5;&quot;&gt;help page&lt;/span&gt;&lt;/a&gt; on the yuzu website.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0" colspan="4">
          <widget class="QLabel" name="label_2">
           <property name="text">
-           <string>To check which hotkeys control the playback/recording, please refer to the Hotkey settings (General -&gt; Hotkeys).</string>
+           <string>To check which hotkeys control the playback/recording, please refer to the Hotkey settings (Configure -&gt; General -&gt; Hotkeys).</string>
           </property>
           <property name="wordWrap">
            <bool>true</bool>

src/yuzu/main.cpp

@@ -66,6 +66,10 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include <QUrl>
 #include <QtConcurrent/QtConcurrent>
 
+#ifdef HAVE_SDL2
+#include <SDL.h> // For SDL ScreenSaver functions
+#endif
+
 #include <fmt/format.h>
 #include "common/detached_tasks.h"
 #include "common/fs/fs.h"
@@ -287,6 +291,14 @@ GMainWindow::GMainWindow()
 
     ui->action_Fullscreen->setChecked(false);
 
+#if defined(HAVE_SDL2) && !defined(_WIN32)
+    SDL_InitSubSystem(SDL_INIT_VIDEO);
+    // SDL disables the screen saver by default, and setting the hint
+    // SDL_HINT_VIDEO_ALLOW_SCREENSAVER doesn't seem to work, so we just enable the screen saver
+    // for now.
+    SDL_EnableScreenSaver();
+#endif
+
     Common::Log::Start();
 
     QStringList args = QApplication::arguments();
@@ -359,8 +371,9 @@ GMainWindow::GMainWindow()
 
 GMainWindow::~GMainWindow() {
     // will get automatically deleted otherwise
-    if (render_window->parent() == nullptr)
+    if (render_window->parent() == nullptr) {
         delete render_window;
+    }
 }
 
 void GMainWindow::RegisterMetaTypes() {
@@ -1225,12 +1238,16 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
 void GMainWindow::PreventOSSleep() {
 #ifdef _WIN32
     SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
+#elif defined(HAVE_SDL2)
+    SDL_DisableScreenSaver();
 #endif
 }
 
 void GMainWindow::AllowOSSleep() {
 #ifdef _WIN32
     SetThreadExecutionState(ES_CONTINUOUS);
+#elif defined(HAVE_SDL2)
+    SDL_EnableScreenSaver();
 #endif
 }
 

src/yuzu_cmd/config.cpp

@@ -412,8 +412,7 @@ void Config::ReadValues() {
 
     const auto custom_rtc_enabled = sdl2_config->GetBoolean("System", "custom_rtc_enabled", false);
     if (custom_rtc_enabled) {
-        Settings::values.custom_rtc =
-            std::chrono::seconds(sdl2_config->GetInteger("System", "custom_rtc", 0));
+        Settings::values.custom_rtc = sdl2_config->GetInteger("System", "custom_rtc", 0);
     } else {
         Settings::values.custom_rtc = std::nullopt;
     }