common/alignment: Fix VS2022 compilation

VS2022 seems to introduce an optimization when moving vectors to check for equality of the element values. AlignmentAllocator needed to overload the equality operator to fix compilation of its usage in vector moving.

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/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/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/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/hle/kernel/k_page_table.cpp

@@ -363,6 +363,8 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st
     block_manager->Update(src_addr, num_pages, KMemoryState::Normal,
                           KMemoryPermission::ReadAndWrite);
 
+    system.InvalidateCpuInstructionCacheRange(dst_addr, size);
+
     return ResultSuccess;
 }
 

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/udp/client.cpp

@@ -471,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/shader_recompiler/ir_opt/texture_pass.cpp

@@ -492,7 +492,8 @@ 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.ShiftRightArithmetic(cbuf.dynamic_offset, shift));
+            inst->SetArg(0, ir.SMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
+                                    ir.Imm32(DESCRIPTOR_SIZE - 1)));
         } else {
             inst->SetArg(0, IR::Value{});
         }

src/video_core/query_cache.h

@@ -258,9 +258,9 @@ private:
 
     void AsyncFlushQuery(VAddr addr) {
         if (!uncommitted_flushes) {
-            uncommitted_flushes = std::make_shared<std::unordered_set<VAddr>>();
+            uncommitted_flushes = std::make_shared<std::vector<VAddr>>();
         }
-        uncommitted_flushes->insert(addr);
+        uncommitted_flushes->push_back(addr);
     }
 
     static constexpr std::uintptr_t PAGE_SIZE = 4096;
@@ -276,8 +276,8 @@ private:
 
     std::array<CounterStream, VideoCore::NumQueryTypes> streams;
 
-    std::shared_ptr<std::unordered_set<VAddr>> uncommitted_flushes{};
-    std::list<std::shared_ptr<std::unordered_set<VAddr>>> committed_flushes;
+    std::shared_ptr<std::vector<VAddr>> uncommitted_flushes{};
+    std::list<std::shared_ptr<std::vector<VAddr>>> committed_flushes;
 };
 
 template <class QueryCache, class HostCounter>

src/video_core/rasterizer_accelerated.h

@@ -42,7 +42,7 @@ private:
     };
     static_assert(sizeof(CacheEntry) == 8, "CacheEntry should be 8 bytes!");
 
-    std::array<CacheEntry, 0x1000000> cached_pages;
+    std::array<CacheEntry, 0x2000000> cached_pages;
     Core::Memory::Memory& cpu_memory;
 };
 

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>

src/video_core/renderer_vulkan/vk_master_semaphore.h

@@ -21,12 +21,12 @@ public:
 
     /// Returns the current logical tick.
     [[nodiscard]] u64 CurrentTick() const noexcept {
-        return current_tick.load(std::memory_order_relaxed);
+        return current_tick.load(std::memory_order_acquire);
     }
 
     /// Returns the last known GPU tick.
     [[nodiscard]] u64 KnownGpuTick() const noexcept {
-        return gpu_tick.load(std::memory_order_relaxed);
+        return gpu_tick.load(std::memory_order_acquire);
     }
 
     /// Returns the timeline semaphore handle.
@@ -41,12 +41,21 @@ public:
 
     /// Advance to the logical tick and return the old one
     [[nodiscard]] u64 NextTick() noexcept {
-        return current_tick.fetch_add(1, std::memory_order::relaxed);
+        return current_tick.fetch_add(1, std::memory_order_release);
     }
 
     /// Refresh the known GPU tick
     void Refresh() {
-        gpu_tick.store(semaphore.GetCounter(), std::memory_order_relaxed);
+        u64 this_tick{};
+        u64 counter{};
+        do {
+            this_tick = gpu_tick.load(std::memory_order_acquire);
+            counter = semaphore.GetCounter();
+            if (counter < this_tick) {
+                return;
+            }
+        } while (!gpu_tick.compare_exchange_weak(this_tick, counter, std::memory_order_release,
+                                                 std::memory_order_relaxed));
     }
 
     /// Waits for a tick to be hit on the GPU

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -117,7 +117,8 @@ u64 HostCounter::BlockingQuery() const {
     cache.GetScheduler().Wait(tick);
     u64 data;
     const VkResult query_result = cache.GetDevice().GetLogical().GetQueryResults(
-        query.first, query.second, 1, sizeof(data), &data, sizeof(data), VK_QUERY_RESULT_64_BIT);
+        query.first, query.second, 1, sizeof(data), &data, sizeof(data),
+        VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
 
     switch (query_result) {
     case VK_SUCCESS:

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_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

@@ -1666,7 +1666,7 @@ void GMainWindow::OnTransferableShaderCacheOpenFile(u64 program_id) {
     const auto shader_cache_folder_path{shader_cache_dir / fmt::format("{:016x}", program_id)};
     if (!Common::FS::CreateDirs(shader_cache_folder_path)) {
         QMessageBox::warning(this, tr("Error Opening Transferable Shader Cache"),
-                             tr("Filed to create the shader cache directory for this title."));
+                             tr("Failed to create the shader cache directory for this title."));
         return;
     }
     const auto shader_path_string{Common::FS::PathToUTF8String(shader_cache_folder_path)};

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;
     }