use e717604a29

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

docs/Caveats.md

@@ -4,7 +4,8 @@
 - [Arch Linux](#arch-linux)
 - [Gentoo Linux](#gentoo-linux)
 - [macOS](#macos)
-- [Solaris](#solaris)
+- [OpenIndiana](#openindiana)
+- [OmniOS](#omnios)
 - [HaikuOS](#haikuos)
 - [OpenBSD](#openbsd)
 - [FreeBSD](#freebsd)
@@ -31,14 +32,14 @@ If you're having issues with building, always consult that ebuild.
 
 macOS is largely untested. Expect crashes, significant Vulkan issues, and other fun stuff.
 
-## Solaris
+## OpenIndiana
 
 Always consult [the OpenIndiana package list](https://pkg.openindiana.org/hipster/en/index.shtml) to cross-verify availability.
 
 Run the usual update + install of essential toolings: `sudo pkg update && sudo pkg install git cmake`.
 
-- **gcc**: `sudo pkg install developer/gcc-14`.
-- **clang**: Version 20 is broken, use `sudo pkg install developer/clang-19`.
+- **gcc**: Install either `developer/gcc-14`.
+- **clang**: Version 20 is broken, install `developer/clang-19`.
 
 Qt Widgets appears to be broken. For now, add `-DENABLE_QT=OFF` to your configure command. In the meantime, a Qt Quick frontend is in the works--check back later!
 
@@ -67,6 +68,31 @@ export LIBGL_ALWAYS_SOFTWARE=1
 - If using OpenIndiana, due to a bug in SDL2's CMake configuration, audio driver defaults to SunOS `<sys/audioio.h>`, which does not exist on OpenIndiana. Using external or bundled SDL2 may solve this.
 - System OpenSSL generally does not work. Instead, use `-DYUZU_USE_BUNDLED_OPENSSL=ON` to use a bundled static OpenSSL, or build a system dependency from source.
 
+## OmniOS
+
+Install `developer/gcc14` on OmniOS using pkgsrc.
+
+Since so many dependencies are missing on `OmniOS`, you may wish to use `-DCPMUTIL_FORCE_BUNDLED=ON -DYUZU_USE_EXTERNAL_SDL2=ON`
+
+For OmniOS you are required to build glslang yourself:
+```sh
+sudo pkg install python-313
+git clone --depth=1 https://github.com/KhronosGroup/glslang.git
+cd glslang
+python3.13 ./update_glslang_sources.py
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -- -j `nproc`
+cmake --install build
+```
+
+It may be tempting to specify `-t glslang`, but this will cause installation to fail. So don't.
+
+Using `--parallel` on CMake incorrectly passes `dmake ... -jn` instead of `dmake ... -j n`, this is a bug with OmniOS's CMake, and as such it's recommended to not use this option until it's fixed.
+
+You may also need to install `gmake` in order to properly build FFmpeg, this is provided by the `build-essential` package.
+
+If it wasn't obvious already, you require a X11 server to properly run the emulator within OmniOS, [this guide](https://web.archive.org/web/20260424200928/https://geekblood.wordpress.com/2017/10/26/installing-x11-and-a-desktop-environment-on-omnios/) is a great starting point for that, the links to pkgsrc are outdated so follow [this exemplar](https://pkgsrc.smartos.org/install-on-illumos/) as well:
+
 ## HaikuOS
 
 It's recommended to do a `pkgman full-sync` before installing. See [HaikuOS: Installing applications](https://www.haiku-os.org/guides/daily-tasks/install-applications/). Sometimes the process may be interrupted by an error like "Interrupted syscall". Simply firing the command again fixes the issue. By default `g++` is included on the default installation.

docs/Deps.md

@@ -291,13 +291,23 @@ pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmak
 
 </details>
 <details>
-<summary>Solaris / OpenIndiana</summary>
+<summary>OpenIndiana</summary>
 
 ```sh
-sudo pkg install qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
+sudo pkg install git cmake qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
 ```
 
-[Caveats](./Caveats.md#solaris).
+[Caveats](./Caveats.md#openindiana).
+
+</details>
+<details>
+<summary>OmniOS</summary>
+
+```sh
+sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13
+```
+
+[Caveats](./Caveats.md#omnios).
 
 </details>
 <details>

externals/cpmfile.json

@@ -208,8 +208,8 @@
     },
     "ffmpeg": {
         "repo": "FFmpeg/FFmpeg",
-        "sha": "c7b5f1537d",
-        "hash": "ed177621176b3961bdcaa339187d3a7688c1c8b060b79c4bb0257cbc67ad7021ae5d5adca5303b45625abbbe3d9aafdd87ce777b8690ac295290d744c875489a",
+        "sha": "e717604a29",
+        "hash": "403390865aa3c0a947679ec2f24076383c72d308dda66918e64526ddc585e652dfda66b724fc04b1625a28c89d428b13d50ae2c19c7a7f16bd5e50904266f302",
         "bundled": true
     },
     "ffmpeg-ci": {

externals/ffmpeg/CMakeLists.txt

@@ -244,7 +244,7 @@ else()
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
     # BSD make or Solaris make don't support ffmpeg make-j8
-    if (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD)
+    if (DEFINED SYSTEM_THREADS AND (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD))
         set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
     else()
         set(FFmpeg_MAKE_ARGS "")

src/android/app/src/main/jni/native.cpp

@@ -1760,7 +1760,7 @@ JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateApkUrl(
 
     const std::string apk_filename = fmt::format("Eden-Android-{}-{}.apk", artifact_str, variant);
 
-    const std::string url = fmt::format("{}/{}/{}",
+    const std::string url = fmt::format("https://{}/{}/{}",
         std::string{Common::g_build_auto_update_api},
         version_str, apk_filename);
 

src/video_core/invalidation_accumulator.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,37 +15,53 @@ public:
     InvalidationAccumulator() = default;
     ~InvalidationAccumulator() = default;
 
-    void Add(GPUVAddr address, size_t size) noexcept {
-        auto const end_address = start_address + accumulated_size;
-        if (!(address >= start_address && address + size <= end_address)) {
-            size = ((address + size + atomicity_size_mask) & atomicity_mask) - address;
-            address = address & atomicity_mask;
-            if (start_address == 0) {
-                start_address = address;
-                accumulated_size = size;
-                // will now have collected as this point
-            } else if (address != end_address) {
+    void Add(GPUVAddr address, size_t size) {
+        const auto reset_values = [&]() {
+            if (has_collected) {
                 buffer.emplace_back(start_address, accumulated_size);
-                start_address = address;
-                accumulated_size = size;
-            } else {
-                accumulated_size += size;
             }
+            start_address = address;
+            accumulated_size = size;
+            last_collection = start_address + size;
+        };
+        if (address >= start_address && address + size <= last_collection) [[likely]] {
+            return;
         }
+        size = ((address + size + atomicity_size_mask) & atomicity_mask) - address;
+        address = address & atomicity_mask;
+        if (!has_collected) [[unlikely]] {
+            reset_values();
+            has_collected = true;
+            return;
+        }
+        if (address != last_collection) [[unlikely]] {
+            reset_values();
+            return;
+        }
+        accumulated_size += size;
+        last_collection += size;
     }
 
-    template <typename F>
-    [[nodiscard]] bool InvalidateAll(F&& f) noexcept {
-        if (start_address > 0) {
-            for (auto [address, size] : buffer)
-                f(address, size);
-            f(start_address, accumulated_size);
-            buffer.clear();
-            start_address = 0;
-            accumulated_size = 0;
-            return true;
+    void Clear() {
+        buffer.clear();
+        start_address = 0;
+        last_collection = 0;
+        has_collected = false;
+    }
+
+    bool AnyAccumulated() const {
+        return has_collected;
+    }
+
+    template <typename Func>
+    void Callback(Func&& func) {
+        if (!has_collected) {
+            return;
+        }
+        buffer.emplace_back(start_address, accumulated_size);
+        for (auto& [address, size] : buffer) {
+            func(address, size);
         }
-        return false;
     }
 
 private:
@@ -56,9 +69,11 @@ private:
     static constexpr size_t atomicity_size = 1ULL << atomicity_bits;
     static constexpr size_t atomicity_size_mask = atomicity_size - 1;
     static constexpr size_t atomicity_mask = ~atomicity_size_mask;
+    GPUVAddr start_address{};
+    GPUVAddr last_collection{};
+    size_t accumulated_size{};
+    bool has_collected{};
     std::vector<std::pair<VAddr, size_t>> buffer;
-    GPUVAddr start_address = 0;
-    size_t accumulated_size = 0;
 };
 
 } // namespace VideoCommon

src/video_core/memory_manager.cpp

@@ -26,14 +26,16 @@ using Tegra::Memory::GuestMemoryFlags;
 
 std::atomic<size_t> MemoryManager::unique_identifier_generator{};
 
-MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_, u64 address_space_bits_, GPUVAddr split_address_, u64 big_page_bits_, u64 page_bits_)
-    : system{system_}, memory{memory_}, address_space_bits{address_space_bits_}
-    , split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_}
-    , entries{}, big_entries{}
-    , page_table{address_space_bits, address_space_bits + page_bits - 38, page_bits != big_page_bits ? page_bits : 0}
-    , kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(1, std::memory_order_acq_rel)}
-    , accumulator{}
-{
+MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager& memory_,
+                             u64 address_space_bits_, GPUVAddr split_address_, u64 big_page_bits_,
+                             u64 page_bits_)
+    : system{system_}, memory{memory_}, address_space_bits{address_space_bits_},
+      split_address{split_address_}, page_bits{page_bits_}, big_page_bits{big_page_bits_},
+      entries{}, big_entries{}, page_table{address_space_bits, address_space_bits + page_bits - 38,
+                                           page_bits != big_page_bits ? page_bits : 0},
+      kind_map{PTEKind::INVALID}, unique_identifier{unique_identifier_generator.fetch_add(
+                                      1, std::memory_order_acq_rel)},
+      accumulator{std::make_unique<VideoCommon::InvalidationAccumulator>()} {
     address_space_size = 1ULL << address_space_bits;
     page_size = 1ULL << page_bits;
     page_mask = page_size - 1ULL;
@@ -52,9 +54,10 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
     entries.resize(page_table_size / 32, 0);
 }
 
-MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_, GPUVAddr split_address_, u64 big_page_bits_, u64 page_bits_)
-    : MemoryManager(system_, system_.Host1x().MemoryManager(), address_space_bits_, split_address_, big_page_bits_, page_bits_)
-{}
+MemoryManager::MemoryManager(Core::System& system_, u64 address_space_bits_,
+                             GPUVAddr split_address_, u64 big_page_bits_, u64 page_bits_)
+    : MemoryManager(system_, system_.Host1x().MemoryManager(), address_space_bits_, split_address_,
+                    big_page_bits_, page_bits_) {}
 
 MemoryManager::~MemoryManager() = default;
 
@@ -466,9 +469,10 @@ void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buf
     WriteBlockImpl<false>(gpu_dest_addr, src_buffer, size, VideoCommon::CacheType::None);
 }
 
-void MemoryManager::WriteBlockCached(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size) {
+void MemoryManager::WriteBlockCached(GPUVAddr gpu_dest_addr, const void* src_buffer,
+                                     std::size_t size) {
     WriteBlockImpl<false>(gpu_dest_addr, src_buffer, size, VideoCommon::CacheType::None);
-    accumulator.Add(gpu_dest_addr, size);
+    accumulator->Add(gpu_dest_addr, size);
 }
 
 void MemoryManager::FlushRegion(GPUVAddr gpu_addr, size_t size,
@@ -752,13 +756,15 @@ void MemoryManager::GetSubmappedRangeImpl(
 }
 
 void MemoryManager::FlushCaching() {
-    // Flush from the invalidate accumulator
-    if (accumulator.InvalidateAll([this](GPUVAddr addr, size_t size) {
-        GetSubmappedRangeImpl<false>(addr, size, page_stash2);
-    })) {
-        rasterizer->InnerInvalidation(VideoCommon::FixSmallVectorADL(page_stash2));
-        page_stash2.clear();
+    if (!accumulator->AnyAccumulated()) {
+        return;
     }
+    accumulator->Callback([this](GPUVAddr addr, size_t size) {
+        GetSubmappedRangeImpl<false>(addr, size, page_stash2);
+    });
+    rasterizer->InnerInvalidation(VideoCommon::FixSmallVectorADL(page_stash2));
+    page_stash2.clear();
+    accumulator->Clear();
 }
 
 const u8* MemoryManager::GetSpan(const GPUVAddr src_addr, const std::size_t size) const {

src/video_core/memory_manager.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -18,7 +18,6 @@
 #include "common/range_map.h"
 #include "common/scratch_buffer.h"
 #include "common/virtual_buffer.h"
-#include "video_core/invalidation_accumulator.h"
 #include "video_core/cache_types.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/pte_kind.h"
@@ -27,6 +26,10 @@ namespace VideoCore {
 class RasterizerInterface;
 }
 
+namespace VideoCommon {
+class InvalidationAccumulator;
+}
+
 namespace Core {
 class System;
 } // namespace Core
@@ -246,7 +249,7 @@ private:
     static constexpr size_t continuous_bits = 64;
 
     const size_t unique_identifier;
-    VideoCommon::InvalidationAccumulator accumulator;
+    std::unique_ptr<VideoCommon::InvalidationAccumulator> accumulator;
 
     static std::atomic<size_t> unique_identifier_generator;