kernel: remove general boost lists

vulkan: pick alpha composite flags based on available values

src/common/intrusive_list.h

@@ -0,0 +1,631 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/parent_of_member.h"
+
+namespace Common {
+
+// Forward declare implementation class for Node.
+namespace impl {
+
+class IntrusiveListImpl;
+
+}
+
+class IntrusiveListNode {
+    YUZU_NON_COPYABLE(IntrusiveListNode);
+
+private:
+    friend class impl::IntrusiveListImpl;
+
+    IntrusiveListNode* m_prev;
+    IntrusiveListNode* m_next;
+
+public:
+    constexpr IntrusiveListNode() : m_prev(this), m_next(this) {}
+
+    constexpr bool IsLinked() const {
+        return m_next != this;
+    }
+
+private:
+    constexpr void LinkPrev(IntrusiveListNode* node) {
+        // We can't link an already linked node.
+        ASSERT(!node->IsLinked());
+        this->SplicePrev(node, node);
+    }
+
+    constexpr void SplicePrev(IntrusiveListNode* first, IntrusiveListNode* last) {
+        // Splice a range into the list.
+        auto last_prev = last->m_prev;
+        first->m_prev = m_prev;
+        last_prev->m_next = this;
+        m_prev->m_next = first;
+        m_prev = last_prev;
+    }
+
+    constexpr void LinkNext(IntrusiveListNode* node) {
+        // We can't link an already linked node.
+        ASSERT(!node->IsLinked());
+        return this->SpliceNext(node, node);
+    }
+
+    constexpr void SpliceNext(IntrusiveListNode* first, IntrusiveListNode* last) {
+        // Splice a range into the list.
+        auto last_prev = last->m_prev;
+        first->m_prev = this;
+        last_prev->m_next = m_next;
+        m_next->m_prev = last_prev;
+        m_next = first;
+    }
+
+    constexpr void Unlink() {
+        this->Unlink(m_next);
+    }
+
+    constexpr void Unlink(IntrusiveListNode* last) {
+        // Unlink a node from a next node.
+        auto last_prev = last->m_prev;
+        m_prev->m_next = last;
+        last->m_prev = m_prev;
+        last_prev->m_next = this;
+        m_prev = last_prev;
+    }
+
+    constexpr IntrusiveListNode* GetPrev() {
+        return m_prev;
+    }
+
+    constexpr const IntrusiveListNode* GetPrev() const {
+        return m_prev;
+    }
+
+    constexpr IntrusiveListNode* GetNext() {
+        return m_next;
+    }
+
+    constexpr const IntrusiveListNode* GetNext() const {
+        return m_next;
+    }
+};
+// DEPRECATED: static_assert(std::is_literal_type<IntrusiveListNode>::value);
+
+namespace impl {
+
+class IntrusiveListImpl {
+    YUZU_NON_COPYABLE(IntrusiveListImpl);
+
+private:
+    IntrusiveListNode m_root_node;
+
+public:
+    template <bool Const>
+    class Iterator;
+
+    using value_type = IntrusiveListNode;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = Iterator<false>;
+    using const_iterator = Iterator<true>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    template <bool Const>
+    class Iterator {
+    public:
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type = typename IntrusiveListImpl::value_type;
+        using difference_type = typename IntrusiveListImpl::difference_type;
+        using pointer =
+            std::conditional_t<Const, IntrusiveListImpl::const_pointer, IntrusiveListImpl::pointer>;
+        using reference = std::conditional_t<Const, IntrusiveListImpl::const_reference,
+                                             IntrusiveListImpl::reference>;
+
+    private:
+        pointer m_node;
+
+    public:
+        constexpr explicit Iterator(pointer n) : m_node(n) {}
+
+        constexpr bool operator==(const Iterator& rhs) const {
+            return m_node == rhs.m_node;
+        }
+
+        constexpr pointer operator->() const {
+            return m_node;
+        }
+
+        constexpr reference operator*() const {
+            return *m_node;
+        }
+
+        constexpr Iterator& operator++() {
+            m_node = m_node->m_next;
+            return *this;
+        }
+
+        constexpr Iterator& operator--() {
+            m_node = m_node->m_prev;
+            return *this;
+        }
+
+        constexpr Iterator operator++(int) {
+            const Iterator it{*this};
+            ++(*this);
+            return it;
+        }
+
+        constexpr Iterator operator--(int) {
+            const Iterator it{*this};
+            --(*this);
+            return it;
+        }
+
+        constexpr operator Iterator<true>() const {
+            return Iterator<true>(m_node);
+        }
+
+        constexpr Iterator<false> GetNonConstIterator() const {
+            return Iterator<false>(const_cast<IntrusiveListImpl::pointer>(m_node));
+        }
+    };
+
+public:
+    constexpr IntrusiveListImpl() : m_root_node() {}
+
+    // Iterator accessors.
+    constexpr iterator begin() {
+        return iterator(m_root_node.GetNext());
+    }
+
+    constexpr const_iterator begin() const {
+        return const_iterator(m_root_node.GetNext());
+    }
+
+    constexpr iterator end() {
+        return iterator(std::addressof(m_root_node));
+    }
+
+    constexpr const_iterator end() const {
+        return const_iterator(std::addressof(m_root_node));
+    }
+
+    constexpr iterator iterator_to(reference v) {
+        // Only allow iterator_to for values in lists.
+        ASSERT(v.IsLinked());
+        return iterator(std::addressof(v));
+    }
+
+    constexpr const_iterator iterator_to(const_reference v) const {
+        // Only allow iterator_to for values in lists.
+        ASSERT(v.IsLinked());
+        return const_iterator(std::addressof(v));
+    }
+
+    // Content management.
+    constexpr bool empty() const {
+        return !m_root_node.IsLinked();
+    }
+
+    constexpr size_type size() const {
+        return static_cast<size_type>(std::distance(this->begin(), this->end()));
+    }
+
+    constexpr reference back() {
+        return *m_root_node.GetPrev();
+    }
+
+    constexpr const_reference back() const {
+        return *m_root_node.GetPrev();
+    }
+
+    constexpr reference front() {
+        return *m_root_node.GetNext();
+    }
+
+    constexpr const_reference front() const {
+        return *m_root_node.GetNext();
+    }
+
+    constexpr void push_back(reference node) {
+        m_root_node.LinkPrev(std::addressof(node));
+    }
+
+    constexpr void push_front(reference node) {
+        m_root_node.LinkNext(std::addressof(node));
+    }
+
+    constexpr void pop_back() {
+        m_root_node.GetPrev()->Unlink();
+    }
+
+    constexpr void pop_front() {
+        m_root_node.GetNext()->Unlink();
+    }
+
+    constexpr iterator insert(const_iterator pos, reference node) {
+        pos.GetNonConstIterator()->LinkPrev(std::addressof(node));
+        return iterator(std::addressof(node));
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveListImpl& o) {
+        splice_impl(pos, o.begin(), o.end());
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveListImpl& o, const_iterator first) {
+        const_iterator last(first);
+        std::advance(last, 1);
+        splice_impl(pos, first, last);
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveListImpl& o, const_iterator first,
+                          const_iterator last) {
+        splice_impl(pos, first, last);
+    }
+
+    constexpr iterator erase(const_iterator pos) {
+        if (pos == this->end()) {
+            return this->end();
+        }
+        iterator it(pos.GetNonConstIterator());
+        (it++)->Unlink();
+        return it;
+    }
+
+    constexpr void clear() {
+        while (!this->empty()) {
+            this->pop_front();
+        }
+    }
+
+private:
+    constexpr void splice_impl(const_iterator _pos, const_iterator _first, const_iterator _last) {
+        if (_first == _last) {
+            return;
+        }
+        iterator pos(_pos.GetNonConstIterator());
+        iterator first(_first.GetNonConstIterator());
+        iterator last(_last.GetNonConstIterator());
+        first->Unlink(std::addressof(*last));
+        pos->SplicePrev(std::addressof(*first), std::addressof(*first));
+    }
+};
+
+} // namespace impl
+
+template <class T, class Traits>
+class IntrusiveList {
+    YUZU_NON_COPYABLE(IntrusiveList);
+
+private:
+    impl::IntrusiveListImpl m_impl;
+
+public:
+    template <bool Const>
+    class Iterator;
+
+    using value_type = T;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = Iterator<false>;
+    using const_iterator = Iterator<true>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    template <bool Const>
+    class Iterator {
+    public:
+        friend class Common::IntrusiveList<T, Traits>;
+
+        using ImplIterator =
+            std::conditional_t<Const, Common::impl::IntrusiveListImpl::const_iterator,
+                               Common::impl::IntrusiveListImpl::iterator>;
+
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type = typename IntrusiveList::value_type;
+        using difference_type = typename IntrusiveList::difference_type;
+        using pointer =
+            std::conditional_t<Const, IntrusiveList::const_pointer, IntrusiveList::pointer>;
+        using reference =
+            std::conditional_t<Const, IntrusiveList::const_reference, IntrusiveList::reference>;
+
+    private:
+        ImplIterator m_iterator;
+
+    private:
+        constexpr explicit Iterator(ImplIterator it) : m_iterator(it) {}
+
+        constexpr ImplIterator GetImplIterator() const {
+            return m_iterator;
+        }
+
+    public:
+        constexpr bool operator==(const Iterator& rhs) const {
+            return m_iterator == rhs.m_iterator;
+        }
+
+        constexpr pointer operator->() const {
+            return std::addressof(Traits::GetParent(*m_iterator));
+        }
+
+        constexpr reference operator*() const {
+            return Traits::GetParent(*m_iterator);
+        }
+
+        constexpr Iterator& operator++() {
+            ++m_iterator;
+            return *this;
+        }
+
+        constexpr Iterator& operator--() {
+            --m_iterator;
+            return *this;
+        }
+
+        constexpr Iterator operator++(int) {
+            const Iterator it{*this};
+            ++m_iterator;
+            return it;
+        }
+
+        constexpr Iterator operator--(int) {
+            const Iterator it{*this};
+            --m_iterator;
+            return it;
+        }
+
+        constexpr operator Iterator<true>() const {
+            return Iterator<true>(m_iterator);
+        }
+    };
+
+private:
+    static constexpr IntrusiveListNode& GetNode(reference ref) {
+        return Traits::GetNode(ref);
+    }
+
+    static constexpr IntrusiveListNode const& GetNode(const_reference ref) {
+        return Traits::GetNode(ref);
+    }
+
+    static constexpr reference GetParent(IntrusiveListNode& node) {
+        return Traits::GetParent(node);
+    }
+
+    static constexpr const_reference GetParent(IntrusiveListNode const& node) {
+        return Traits::GetParent(node);
+    }
+
+public:
+    constexpr IntrusiveList() : m_impl() {}
+
+    // Iterator accessors.
+    constexpr iterator begin() {
+        return iterator(m_impl.begin());
+    }
+
+    constexpr const_iterator begin() const {
+        return const_iterator(m_impl.begin());
+    }
+
+    constexpr iterator end() {
+        return iterator(m_impl.end());
+    }
+
+    constexpr const_iterator end() const {
+        return const_iterator(m_impl.end());
+    }
+
+    constexpr const_iterator cbegin() const {
+        return this->begin();
+    }
+
+    constexpr const_iterator cend() const {
+        return this->end();
+    }
+
+    constexpr reverse_iterator rbegin() {
+        return reverse_iterator(this->end());
+    }
+
+    constexpr const_reverse_iterator rbegin() const {
+        return const_reverse_iterator(this->end());
+    }
+
+    constexpr reverse_iterator rend() {
+        return reverse_iterator(this->begin());
+    }
+
+    constexpr const_reverse_iterator rend() const {
+        return const_reverse_iterator(this->begin());
+    }
+
+    constexpr const_reverse_iterator crbegin() const {
+        return this->rbegin();
+    }
+
+    constexpr const_reverse_iterator crend() const {
+        return this->rend();
+    }
+
+    constexpr iterator iterator_to(reference v) {
+        return iterator(m_impl.iterator_to(GetNode(v)));
+    }
+
+    constexpr const_iterator iterator_to(const_reference v) const {
+        return const_iterator(m_impl.iterator_to(GetNode(v)));
+    }
+
+    // Content management.
+    constexpr bool empty() const {
+        return m_impl.empty();
+    }
+
+    constexpr size_type size() const {
+        return m_impl.size();
+    }
+
+    constexpr reference back() {
+        return GetParent(m_impl.back());
+    }
+
+    constexpr const_reference back() const {
+        return GetParent(m_impl.back());
+    }
+
+    constexpr reference front() {
+        return GetParent(m_impl.front());
+    }
+
+    constexpr const_reference front() const {
+        return GetParent(m_impl.front());
+    }
+
+    constexpr void push_back(reference ref) {
+        m_impl.push_back(GetNode(ref));
+    }
+
+    constexpr void push_front(reference ref) {
+        m_impl.push_front(GetNode(ref));
+    }
+
+    constexpr void pop_back() {
+        m_impl.pop_back();
+    }
+
+    constexpr void pop_front() {
+        m_impl.pop_front();
+    }
+
+    constexpr iterator insert(const_iterator pos, reference ref) {
+        return iterator(m_impl.insert(pos.GetImplIterator(), GetNode(ref)));
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveList& o) {
+        m_impl.splice(pos.GetImplIterator(), o.m_impl);
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveList& o, const_iterator first) {
+        m_impl.splice(pos.GetImplIterator(), o.m_impl, first.GetImplIterator());
+    }
+
+    constexpr void splice(const_iterator pos, IntrusiveList& o, const_iterator first,
+                          const_iterator last) {
+        m_impl.splice(pos.GetImplIterator(), o.m_impl, first.GetImplIterator(),
+                      last.GetImplIterator());
+    }
+
+    constexpr iterator erase(const_iterator pos) {
+        return iterator(m_impl.erase(pos.GetImplIterator()));
+    }
+
+    constexpr void clear() {
+        m_impl.clear();
+    }
+};
+
+template <auto T, class Derived = Common::impl::GetParentType<T>>
+class IntrusiveListMemberTraits;
+
+template <class Parent, IntrusiveListNode Parent::*Member, class Derived>
+class IntrusiveListMemberTraits<Member, Derived> {
+public:
+    using ListType = IntrusiveList<Derived, IntrusiveListMemberTraits>;
+
+private:
+    friend class IntrusiveList<Derived, IntrusiveListMemberTraits>;
+
+    static constexpr IntrusiveListNode& GetNode(Derived& parent) {
+        return parent.*Member;
+    }
+
+    static constexpr IntrusiveListNode const& GetNode(Derived const& parent) {
+        return parent.*Member;
+    }
+
+    static Derived& GetParent(IntrusiveListNode& node) {
+        return Common::GetParentReference<Member, Derived>(std::addressof(node));
+    }
+
+    static Derived const& GetParent(IntrusiveListNode const& node) {
+        return Common::GetParentReference<Member, Derived>(std::addressof(node));
+    }
+};
+
+template <auto T, class Derived = Common::impl::GetParentType<T>>
+class IntrusiveListMemberTraitsByNonConstexprOffsetOf;
+
+template <class Parent, IntrusiveListNode Parent::*Member, class Derived>
+class IntrusiveListMemberTraitsByNonConstexprOffsetOf<Member, Derived> {
+public:
+    using ListType = IntrusiveList<Derived, IntrusiveListMemberTraitsByNonConstexprOffsetOf>;
+
+private:
+    friend class IntrusiveList<Derived, IntrusiveListMemberTraitsByNonConstexprOffsetOf>;
+
+    static constexpr IntrusiveListNode& GetNode(Derived& parent) {
+        return parent.*Member;
+    }
+
+    static constexpr IntrusiveListNode const& GetNode(Derived const& parent) {
+        return parent.*Member;
+    }
+
+    static Derived& GetParent(IntrusiveListNode& node) {
+        return *reinterpret_cast<Derived*>(reinterpret_cast<char*>(std::addressof(node)) -
+                                           GetOffset());
+    }
+
+    static Derived const& GetParent(IntrusiveListNode const& node) {
+        return *reinterpret_cast<const Derived*>(
+            reinterpret_cast<const char*>(std::addressof(node)) - GetOffset());
+    }
+
+    static uintptr_t GetOffset() {
+        return reinterpret_cast<uintptr_t>(std::addressof(reinterpret_cast<Derived*>(0)->*Member));
+    }
+};
+
+template <class Derived>
+class IntrusiveListBaseNode : public IntrusiveListNode {};
+
+template <class Derived>
+class IntrusiveListBaseTraits {
+public:
+    using ListType = IntrusiveList<Derived, IntrusiveListBaseTraits>;
+
+private:
+    friend class IntrusiveList<Derived, IntrusiveListBaseTraits>;
+
+    static constexpr IntrusiveListNode& GetNode(Derived& parent) {
+        return static_cast<IntrusiveListNode&>(
+            static_cast<IntrusiveListBaseNode<Derived>&>(parent));
+    }
+
+    static constexpr IntrusiveListNode const& GetNode(Derived const& parent) {
+        return static_cast<const IntrusiveListNode&>(
+            static_cast<const IntrusiveListBaseNode<Derived>&>(parent));
+    }
+
+    static constexpr Derived& GetParent(IntrusiveListNode& node) {
+        return static_cast<Derived&>(static_cast<IntrusiveListBaseNode<Derived>&>(node));
+    }
+
+    static constexpr Derived const& GetParent(IntrusiveListNode const& node) {
+        return static_cast<const Derived&>(
+            static_cast<const IntrusiveListBaseNode<Derived>&>(node));
+    }
+};
+
+} // namespace Common

src/core/hle/kernel/k_event_info.h

@@ -5,14 +5,15 @@
 
 #include <array>
 
-#include <boost/intrusive/list.hpp>
+#include "common/intrusive_list.h"
 
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_types.h"
 
 namespace Kernel {
 
-class KEventInfo : public KSlabAllocated<KEventInfo>, public boost::intrusive::list_base_hook<> {
+class KEventInfo : public KSlabAllocated<KEventInfo>,
+                   public Common::IntrusiveListBaseNode<KEventInfo> {
 public:
     struct InfoCreateThread {
         u32 thread_id{};

src/core/hle/kernel/k_object_name.h

@@ -5,7 +5,8 @@
 
 #include <array>
 #include <memory>
-#include <boost/intrusive/list.hpp>
+
+#include "common/intrusive_list.h"
 
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/slab_helpers.h"
@@ -15,13 +16,14 @@ namespace Kernel {
 
 class KObjectNameGlobalData;
 
-class KObjectName : public KSlabAllocated<KObjectName>, public boost::intrusive::list_base_hook<> {
+class KObjectName : public KSlabAllocated<KObjectName>,
+                    public Common::IntrusiveListBaseNode<KObjectName> {
 public:
     explicit KObjectName(KernelCore&) {}
     virtual ~KObjectName() = default;
 
     static constexpr size_t NameLengthMax = 12;
-    using List = boost::intrusive::list<KObjectName>;
+    using List = Common::IntrusiveListBaseTraits<KObjectName>::ListType;
 
     static Result NewFromName(KernelCore& kernel, KAutoObject* obj, const char* name);
     static Result Delete(KernelCore& kernel, KAutoObject* obj, const char* name);

src/core/hle/kernel/k_server_port.h

@@ -7,7 +7,7 @@
 #include <string>
 #include <utility>
 
-#include <boost/intrusive/list.hpp>
+#include "common/intrusive_list.h"
 
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/k_synchronization_object.h"
@@ -42,7 +42,7 @@ public:
     bool IsSignaled() const override;
 
 private:
-    using SessionList = boost::intrusive::list<KServerSession>;
+    using SessionList = Common::IntrusiveListBaseTraits<KServerSession>::ListType;
 
     void CleanupSessions();
 

src/core/hle/kernel/k_server_session.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <utility>
 
-#include <boost/intrusive/list.hpp>
+#include "common/intrusive_list.h"
 
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_session_request.h"
@@ -27,7 +27,7 @@ class KSession;
 class KThread;
 
 class KServerSession final : public KSynchronizationObject,
-                             public boost::intrusive::list_base_hook<> {
+                             public Common::IntrusiveListBaseNode<KServerSession> {
     KERNEL_AUTOOBJECT_TRAITS(KServerSession, KSynchronizationObject);
 
     friend class ServiceThread;
@@ -67,7 +67,8 @@ private:
     KSession* m_parent{};
 
     /// List of threads which are pending a reply.
-    boost::intrusive::list<KSessionRequest> m_request_list{};
+    using RequestList = Common::IntrusiveListBaseTraits<KSessionRequest>::ListType;
+    RequestList m_request_list{};
     KSessionRequest* m_current_request{};
 
     KLightLock m_lock;

src/core/hle/kernel/k_session_request.h

@@ -5,6 +5,8 @@
 
 #include <array>
 
+#include "common/intrusive_list.h"
+
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_memory_block.h"
@@ -16,7 +18,7 @@ namespace Kernel {
 
 class KSessionRequest final : public KSlabAllocated<KSessionRequest>,
                               public KAutoObject,
-                              public boost::intrusive::list_base_hook<> {
+                              public Common::IntrusiveListBaseNode<KSessionRequest> {
     KERNEL_AUTOOBJECT_TRAITS(KSessionRequest, KAutoObject);
 
 public:

src/core/hle/kernel/k_shared_memory_info.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <boost/intrusive/list.hpp>
+#include "common/intrusive_list.h"
 
 #include "core/hle/kernel/slab_helpers.h"
 
@@ -12,7 +12,7 @@ namespace Kernel {
 class KSharedMemory;
 
 class KSharedMemoryInfo final : public KSlabAllocated<KSharedMemoryInfo>,
-                                public boost::intrusive::list_base_hook<> {
+                                public Common::IntrusiveListBaseNode<KSharedMemoryInfo> {
 
 public:
     explicit KSharedMemoryInfo(KernelCore&) {}

src/core/hle/kernel/k_thread.h

@@ -12,7 +12,7 @@
 #include <utility>
 #include <vector>
 
-#include <boost/intrusive/list.hpp>
+#include "common/intrusive_list.h"
 
 #include "common/intrusive_red_black_tree.h"
 #include "common/spin_lock.h"
@@ -119,7 +119,7 @@ s32 GetCurrentCoreId(KernelCore& kernel);
 Core::Memory::Memory& GetCurrentMemory(KernelCore& kernel);
 
 class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
-                      public boost::intrusive::list_base_hook<>,
+                      public Common::IntrusiveListBaseNode<KThread>,
                       public KTimerTask {
     KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject);
 
@@ -138,7 +138,7 @@ public:
 public:
     using ThreadContext32 = Core::ARM_Interface::ThreadContext32;
     using ThreadContext64 = Core::ARM_Interface::ThreadContext64;
-    using WaiterList = boost::intrusive::list<KThread>;
+    using WaiterList = Common::IntrusiveListBaseTraits<KThread>::ListType;
 
     /**
      * Gets the thread's current priority
@@ -750,8 +750,9 @@ private:
         ConditionVariableThreadTreeTraits::TreeType<LockWithPriorityInheritanceComparator>;
 
 public:
-    class LockWithPriorityInheritanceInfo : public KSlabAllocated<LockWithPriorityInheritanceInfo>,
-                                            public boost::intrusive::list_base_hook<> {
+    class LockWithPriorityInheritanceInfo
+        : public KSlabAllocated<LockWithPriorityInheritanceInfo>,
+          public Common::IntrusiveListBaseNode<LockWithPriorityInheritanceInfo> {
     public:
         explicit LockWithPriorityInheritanceInfo(KernelCore&) {}
 
@@ -839,7 +840,7 @@ public:
 
 private:
     using LockWithPriorityInheritanceInfoList =
-        boost::intrusive::list<LockWithPriorityInheritanceInfo>;
+        Common::IntrusiveListBaseTraits<LockWithPriorityInheritanceInfo>::ListType;
 
     ConditionVariableThreadTree* m_condvar_tree{};
     u64 m_condvar_key{};

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

@@ -49,12 +49,6 @@ public:
         };
         // clang-format on
         RegisterHandlers(functions);
-
-        if (impl->GetSystem()
-                .Initialize(device_name, in_params, handle, applet_resource_user_id)
-                .IsError()) {
-            LOG_ERROR(Service_Audio, "Failed to initialize the AudioOut System!");
-        }
     }
 
     ~IAudioOut() override {
@@ -287,6 +281,14 @@ void AudOutU::OpenAudioOut(HLERequestContext& ctx) {
 
     auto audio_out = std::make_shared<IAudioOut>(system, *impl, new_session_id, device_name,
                                                  in_params, handle, applet_resource_user_id);
+    result = audio_out->GetImpl()->GetSystem().Initialize(device_name, in_params, handle,
+                                                          applet_resource_user_id);
+    if (result.IsError()) {
+        LOG_ERROR(Service_Audio, "Failed to initialize the AudioOut System!");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
 
     impl->sessions[new_session_id] = audio_out->GetImpl();
     impl->applet_resource_user_ids[new_session_id] = applet_resource_user_id;

src/core/memory.cpp

@@ -462,7 +462,7 @@ struct Memory::Impl {
         }
 
         if (Settings::IsFastmemEnabled()) {
-            const bool is_read_enable = !Settings::IsGPULevelExtreme() || !cached;
+            const bool is_read_enable = Settings::IsGPULevelHigh() || !cached;
             system.DeviceMemory().buffer.Protect(vaddr, size, is_read_enable, !cached);
         }
 

src/video_core/engines/maxwell_3d.cpp

@@ -4,6 +4,7 @@
 #include <cstring>
 #include <optional>
 #include "common/assert.h"
+#include "common/bit_util.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/core.h"
@@ -259,12 +260,13 @@ u32 Maxwell3D::GetMaxCurrentVertices() {
 size_t Maxwell3D::EstimateIndexBufferSize() {
     GPUVAddr start_address = regs.index_buffer.StartAddress();
     GPUVAddr end_address = regs.index_buffer.EndAddress();
-    static constexpr std::array<size_t, 4> max_sizes = {
-        std::numeric_limits<u8>::max(), std::numeric_limits<u16>::max(),
-        std::numeric_limits<u32>::max(), std::numeric_limits<u32>::max()};
+    static constexpr std::array<size_t, 3> max_sizes = {std::numeric_limits<u8>::max(),
+                                                        std::numeric_limits<u16>::max(),
+                                                        std::numeric_limits<u32>::max()};
     const size_t byte_size = regs.index_buffer.FormatSizeInBytes();
+    const size_t log2_byte_size = Common::Log2Ceil64(byte_size);
     return std::min<size_t>(
-        memory_manager.GetMemoryLayoutSize(start_address, byte_size * max_sizes[byte_size]) /
+        memory_manager.GetMemoryLayoutSize(start_address, byte_size * max_sizes[log2_byte_size]) /
             byte_size,
         static_cast<size_t>(end_address - start_address));
 }

src/video_core/fence_manager.h

@@ -4,20 +4,13 @@
 #pragma once
 
 #include <algorithm>
-#include <condition_variable>
 #include <cstring>
 #include <deque>
 #include <functional>
 #include <memory>
-#include <mutex>
-#include <thread>
 #include <queue>
 
 #include "common/common_types.h"
-#include "common/microprofile.h"
-#include "common/scope_exit.h"
-#include "common/settings.h"
-#include "common/thread.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/gpu.h"
 #include "video_core/host1x/host1x.h"
@@ -30,26 +23,15 @@ class FenceBase {
 public:
     explicit FenceBase(bool is_stubbed_) : is_stubbed{is_stubbed_} {}
 
-    bool IsStubbed() const {
-        return is_stubbed;
-    }
-
 protected:
     bool is_stubbed;
 };
 
-template <typename Traits>
+template <typename TFence, typename TTextureCache, typename TTBufferCache, typename TQueryCache>
 class FenceManager {
-    using TFence = typename Traits::FenceType;
-    using TTextureCache = typename Traits::TextureCacheType;
-    using TBufferCache = typename Traits::BufferCacheType;
-    using TQueryCache = typename Traits::QueryCacheType;
-    static constexpr bool can_async_check = Traits::HAS_ASYNC_CHECK;
-
 public:
     /// Notify the fence manager about a new frame
     void TickFrame() {
-        std::unique_lock lock(ring_guard);
         delayed_destruction_ring.Tick();
     }
 
@@ -64,33 +46,17 @@ public:
     }
 
     void SignalFence(std::function<void()>&& func) {
-        rasterizer.InvalidateGPUCache();
-        bool delay_fence = Settings::IsGPULevelHigh();
-        if constexpr (!can_async_check) {
-            TryReleasePendingFences<false>();
-        }
+        TryReleasePendingFences();
         const bool should_flush = ShouldFlush();
         CommitAsyncFlushes();
+        uncommitted_operations.emplace_back(std::move(func));
+        CommitOperations();
         TFence new_fence = CreateFence(!should_flush);
-        if constexpr (can_async_check) {
-            guard.lock();
-        }
-        if (delay_fence) {
-            uncommitted_operations.emplace_back(std::move(func));
-        }
-        pending_operations.emplace_back(std::move(uncommitted_operations));
+        fences.push(new_fence);
         QueueFence(new_fence);
-        if (!delay_fence) {
-            func();
-        }
-        fences.push(std::move(new_fence));
         if (should_flush) {
             rasterizer.FlushCommands();
         }
-        if constexpr (can_async_check) {
-            guard.unlock();
-            cv.notify_all();
-        }
     }
 
     void SignalSyncPoint(u32 value) {
@@ -100,30 +66,29 @@ public:
     }
 
     void WaitPendingFences() {
-        if constexpr (!can_async_check) {
-            TryReleasePendingFences<true>();
+        while (!fences.empty()) {
+            TFence& current_fence = fences.front();
+            if (ShouldWait()) {
+                WaitFence(current_fence);
+            }
+            PopAsyncFlushes();
+            auto operations = std::move(pending_operations.front());
+            pending_operations.pop_front();
+            for (auto& operation : operations) {
+                operation();
+            }
+            PopFence();
         }
     }
 
 protected:
     explicit FenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
-                          TTextureCache& texture_cache_, TBufferCache& buffer_cache_,
+                          TTextureCache& texture_cache_, TTBufferCache& buffer_cache_,
                           TQueryCache& query_cache_)
         : rasterizer{rasterizer_}, gpu{gpu_}, syncpoint_manager{gpu.Host1x().GetSyncpointManager()},
-          texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, query_cache{query_cache_} {
-        if constexpr (can_async_check) {
-            fence_thread =
-                std::jthread([this](std::stop_token token) { ReleaseThreadFunc(token); });
-        }
-    }
+          texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, query_cache{query_cache_} {}
 
-    virtual ~FenceManager() {
-        if constexpr (can_async_check) {
-            fence_thread.request_stop();
-            cv.notify_all();
-            fence_thread.join();
-        }
-    }
+    virtual ~FenceManager() = default;
 
     /// Creates a Fence Interface, does not create a backend fence if 'is_stubbed' is
     /// true
@@ -139,20 +104,15 @@ protected:
     Tegra::GPU& gpu;
     Tegra::Host1x::SyncpointManager& syncpoint_manager;
     TTextureCache& texture_cache;
-    TBufferCache& buffer_cache;
+    TTBufferCache& buffer_cache;
     TQueryCache& query_cache;
 
 private:
-    template <bool force_wait>
     void TryReleasePendingFences() {
         while (!fences.empty()) {
             TFence& current_fence = fences.front();
             if (ShouldWait() && !IsFenceSignaled(current_fence)) {
-                if constexpr (force_wait) {
-                    WaitFence(current_fence);
-                } else {
-                    return;
-                }
+                return;
             }
             PopAsyncFlushes();
             auto operations = std::move(pending_operations.front());
@@ -160,49 +120,7 @@ private:
             for (auto& operation : operations) {
                 operation();
             }
-            {
-                std::unique_lock lock(ring_guard);
-                delayed_destruction_ring.Push(std::move(current_fence));
-            }
-            fences.pop();
-        }
-    }
-
-    void ReleaseThreadFunc(std::stop_token stop_token) {
-        std::string name = "GPUFencingThread";
-        MicroProfileOnThreadCreate(name.c_str());
-
-        // Cleanup
-        SCOPE_EXIT({ MicroProfileOnThreadExit(); });
-
-        Common::SetCurrentThreadName(name.c_str());
-        Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
-
-        TFence current_fence;
-        std::deque<std::function<void()>> current_operations;
-        while (!stop_token.stop_requested()) {
-            {
-                std::unique_lock lock(guard);
-                cv.wait(lock, [&] { return stop_token.stop_requested() || !fences.empty(); });
-                if (stop_token.stop_requested()) [[unlikely]] {
-                    return;
-                }
-                current_fence = std::move(fences.front());
-                current_operations = std::move(pending_operations.front());
-                fences.pop();
-                pending_operations.pop_front();
-            }
-            if (!current_fence->IsStubbed()) {
-                WaitFence(current_fence);
-            }
-            PopAsyncFlushes();
-            for (auto& operation : current_operations) {
-                operation();
-            }
-            {
-                std::unique_lock lock(ring_guard);
-                delayed_destruction_ring.Push(std::move(current_fence));
-            }
+            PopFence();
         }
     }
 
@@ -236,16 +154,19 @@ private:
         query_cache.CommitAsyncFlushes();
     }
 
+    void PopFence() {
+        delayed_destruction_ring.Push(std::move(fences.front()));
+        fences.pop();
+    }
+
+    void CommitOperations() {
+        pending_operations.emplace_back(std::move(uncommitted_operations));
+    }
+
     std::queue<TFence> fences;
     std::deque<std::function<void()>> uncommitted_operations;
     std::deque<std::deque<std::function<void()>>> pending_operations;
 
-    std::mutex guard;
-    std::mutex ring_guard;
-    std::condition_variable cv;
-
-    std::jthread fence_thread;
-
     DelayedDestructionRing<TFence, 6> delayed_destruction_ring;
 };
 

src/video_core/memory_manager.cpp

@@ -170,7 +170,6 @@ void MemoryManager::BindRasterizer(VideoCore::RasterizerInterface* rasterizer_)
 
 GPUVAddr MemoryManager::Map(GPUVAddr gpu_addr, VAddr cpu_addr, std::size_t size, PTEKind kind,
                             bool is_big_pages) {
-    std::unique_lock<std::mutex> lock(guard);
     if (is_big_pages) [[likely]] {
         return BigPageTableOp<EntryType::Mapped>(gpu_addr, cpu_addr, size, kind);
     }
@@ -178,7 +177,6 @@ GPUVAddr MemoryManager::Map(GPUVAddr gpu_addr, VAddr cpu_addr, std::size_t size,
 }
 
 GPUVAddr MemoryManager::MapSparse(GPUVAddr gpu_addr, std::size_t size, bool is_big_pages) {
-    std::unique_lock<std::mutex> lock(guard);
     if (is_big_pages) [[likely]] {
         return BigPageTableOp<EntryType::Reserved>(gpu_addr, 0, size, PTEKind::INVALID);
     }
@@ -189,7 +187,6 @@ void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
     if (size == 0) {
         return;
     }
-    std::unique_lock<std::mutex> lock(guard);
     GetSubmappedRangeImpl<false>(gpu_addr, size, page_stash);
 
     for (const auto& [map_addr, map_size] : page_stash) {
@@ -556,7 +553,6 @@ size_t MemoryManager::MaxContinuousRange(GPUVAddr gpu_addr, size_t size) const {
 }
 
 size_t MemoryManager::GetMemoryLayoutSize(GPUVAddr gpu_addr, size_t max_size) const {
-    std::unique_lock<std::mutex> lock(guard);
     return kind_map.GetContinuousSizeFrom(gpu_addr);
 }
 
@@ -749,10 +745,10 @@ void MemoryManager::FlushCaching() {
         return;
     }
     accumulator->Callback([this](GPUVAddr addr, size_t size) {
-        GetSubmappedRangeImpl<false>(addr, size, page_stash2);
+        GetSubmappedRangeImpl<false>(addr, size, page_stash);
     });
-    rasterizer->InnerInvalidation(page_stash2);
-    page_stash2.clear();
+    rasterizer->InnerInvalidation(page_stash);
+    page_stash.clear();
     accumulator->Clear();
 }
 

src/video_core/memory_manager.h

@@ -5,7 +5,6 @@
 
 #include <atomic>
 #include <map>
-#include <mutex>
 #include <optional>
 #include <vector>
 
@@ -216,9 +215,6 @@ private:
 
     std::vector<u64> big_page_continuous;
     std::vector<std::pair<VAddr, std::size_t>> page_stash{};
-    std::vector<std::pair<VAddr, std::size_t>> page_stash2{};
-
-    mutable std::mutex guard;
 
     static constexpr size_t continuous_bits = 64;
 

src/video_core/query_cache.h

@@ -6,7 +6,6 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
-#include <functional>
 #include <iterator>
 #include <list>
 #include <memory>
@@ -18,19 +17,13 @@
 
 #include "common/assert.h"
 #include "common/settings.h"
-#include "core/memory.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
-#include "video_core/texture_cache/slot_vector.h"
 
 namespace VideoCommon {
 
-using AsyncJobId = SlotId;
-
-static constexpr AsyncJobId NULL_ASYNC_JOB_ID{0};
-
 template <class QueryCache, class HostCounter>
 class CounterStreamBase {
 public:
@@ -100,13 +93,9 @@ private:
 template <class QueryCache, class CachedQuery, class CounterStream, class HostCounter>
 class QueryCacheBase : public VideoCommon::ChannelSetupCaches<VideoCommon::ChannelInfo> {
 public:
-    explicit QueryCacheBase(VideoCore::RasterizerInterface& rasterizer_,
-                            Core::Memory::Memory& cpu_memory_)
-        : rasterizer{rasterizer_},
-          cpu_memory{cpu_memory_}, streams{{CounterStream{static_cast<QueryCache&>(*this),
-                                                          VideoCore::QueryType::SamplesPassed}}} {
-        (void)slot_async_jobs.insert(); // Null value
-    }
+    explicit QueryCacheBase(VideoCore::RasterizerInterface& rasterizer_)
+        : rasterizer{rasterizer_}, streams{{CounterStream{static_cast<QueryCache&>(*this),
+                                                          VideoCore::QueryType::SamplesPassed}}} {}
 
     void InvalidateRegion(VAddr addr, std::size_t size) {
         std::unique_lock lock{mutex};
@@ -137,15 +126,10 @@ public:
             query = Register(type, *cpu_addr, host_ptr, timestamp.has_value());
         }
 
-        auto result = query->BindCounter(Stream(type).Current(), timestamp);
-        if (result) {
-            auto async_job_id = query->GetAsyncJob();
-            auto& async_job = slot_async_jobs[async_job_id];
-            async_job.collected = true;
-            async_job.value = *result;
-            query->SetAsyncJob(NULL_ASYNC_JOB_ID);
+        query->BindCounter(Stream(type).Current(), timestamp);
+        if (Settings::values.use_asynchronous_gpu_emulation.GetValue()) {
+            AsyncFlushQuery(*cpu_addr);
         }
-        AsyncFlushQuery(query, timestamp, lock);
     }
 
     /// Updates counters from GPU state. Expected to be called once per draw, clear or dispatch.
@@ -189,18 +173,15 @@ public:
     }
 
     void CommitAsyncFlushes() {
-        std::unique_lock lock{mutex};
         committed_flushes.push_back(uncommitted_flushes);
         uncommitted_flushes.reset();
     }
 
     bool HasUncommittedFlushes() const {
-        std::unique_lock lock{mutex};
         return uncommitted_flushes != nullptr;
     }
 
     bool ShouldWaitAsyncFlushes() const {
-        std::unique_lock lock{mutex};
         if (committed_flushes.empty()) {
             return false;
         }
@@ -208,7 +189,6 @@ public:
     }
 
     void PopAsyncFlushes() {
-        std::unique_lock lock{mutex};
         if (committed_flushes.empty()) {
             return;
         }
@@ -217,25 +197,15 @@ public:
             committed_flushes.pop_front();
             return;
         }
-        for (AsyncJobId async_job_id : *flush_list) {
-            AsyncJob& async_job = slot_async_jobs[async_job_id];
-            if (!async_job.collected) {
-                FlushAndRemoveRegion(async_job.query_location, 2, true);
-            }
+        for (VAddr query_address : *flush_list) {
+            FlushAndRemoveRegion(query_address, 4);
         }
         committed_flushes.pop_front();
     }
 
 private:
-    struct AsyncJob {
-        bool collected = false;
-        u64 value = 0;
-        VAddr query_location = 0;
-        std::optional<u64> timestamp{};
-    };
-
     /// Flushes a memory range to guest memory and removes it from the cache.
-    void FlushAndRemoveRegion(VAddr addr, std::size_t size, bool async = false) {
+    void FlushAndRemoveRegion(VAddr addr, std::size_t size) {
         const u64 addr_begin = addr;
         const u64 addr_end = addr_begin + size;
         const auto in_range = [addr_begin, addr_end](const CachedQuery& query) {
@@ -256,16 +226,7 @@ private:
                     continue;
                 }
                 rasterizer.UpdatePagesCachedCount(query.GetCpuAddr(), query.SizeInBytes(), -1);
-                AsyncJobId async_job_id = query.GetAsyncJob();
-                auto flush_result = query.Flush(async);
-                if (async_job_id == NULL_ASYNC_JOB_ID) {
-                    ASSERT_MSG(false, "This should not be reachable at all");
-                    continue;
-                }
-                AsyncJob& async_job = slot_async_jobs[async_job_id];
-                async_job.collected = true;
-                async_job.value = flush_result;
-                query.SetAsyncJob(NULL_ASYNC_JOB_ID);
+                query.Flush();
             }
             std::erase_if(contents, in_range);
         }
@@ -292,60 +253,26 @@ private:
         return found != std::end(contents) ? &*found : nullptr;
     }
 
-    void AsyncFlushQuery(CachedQuery* query, std::optional<u64> timestamp,
-                         std::unique_lock<std::recursive_mutex>& lock) {
-        const AsyncJobId new_async_job_id = slot_async_jobs.insert();
-        {
-            AsyncJob& async_job = slot_async_jobs[new_async_job_id];
-            query->SetAsyncJob(new_async_job_id);
-            async_job.query_location = query->GetCpuAddr();
-            async_job.collected = false;
-
-            if (!uncommitted_flushes) {
-                uncommitted_flushes = std::make_shared<std::vector<AsyncJobId>>();
-            }
-            uncommitted_flushes->push_back(new_async_job_id);
+    void AsyncFlushQuery(VAddr addr) {
+        if (!uncommitted_flushes) {
+            uncommitted_flushes = std::make_shared<std::vector<VAddr>>();
         }
-        lock.unlock();
-        std::function<void()> operation([this, new_async_job_id, timestamp] {
-            std::unique_lock local_lock{mutex};
-            AsyncJob& async_job = slot_async_jobs[new_async_job_id];
-            u64 value = async_job.value;
-            VAddr address = async_job.query_location;
-            slot_async_jobs.erase(new_async_job_id);
-            local_lock.unlock();
-            if (timestamp) {
-                u64 timestamp_value = *timestamp;
-                cpu_memory.WriteBlockUnsafe(address + sizeof(u64), &timestamp_value, sizeof(u64));
-                cpu_memory.WriteBlockUnsafe(address, &value, sizeof(u64));
-                rasterizer.InvalidateRegion(address, sizeof(u64) * 2,
-                                            VideoCommon::CacheType::NoQueryCache);
-            } else {
-                u32 small_value = static_cast<u32>(value);
-                cpu_memory.WriteBlockUnsafe(address, &small_value, sizeof(u32));
-                rasterizer.InvalidateRegion(address, sizeof(u32),
-                                            VideoCommon::CacheType::NoQueryCache);
-            }
-        });
-        rasterizer.SyncOperation(std::move(operation));
+        uncommitted_flushes->push_back(addr);
     }
 
     static constexpr std::uintptr_t YUZU_PAGESIZE = 4096;
     static constexpr unsigned YUZU_PAGEBITS = 12;
 
-    SlotVector<AsyncJob> slot_async_jobs;
-
     VideoCore::RasterizerInterface& rasterizer;
-    Core::Memory::Memory& cpu_memory;
 
-    mutable std::recursive_mutex mutex;
+    std::recursive_mutex mutex;
 
     std::unordered_map<u64, std::vector<CachedQuery>> cached_queries;
 
     std::array<CounterStream, VideoCore::NumQueryTypes> streams;
 
-    std::shared_ptr<std::vector<AsyncJobId>> uncommitted_flushes{};
-    std::list<std::shared_ptr<std::vector<AsyncJobId>>> 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>
@@ -364,12 +291,12 @@ public:
     virtual ~HostCounterBase() = default;
 
     /// Returns the current value of the query.
-    u64 Query(bool async = false) {
+    u64 Query() {
         if (result) {
             return *result;
         }
 
-        u64 value = BlockingQuery(async) + base_result;
+        u64 value = BlockingQuery() + base_result;
         if (dependency) {
             value += dependency->Query();
             dependency = nullptr;
@@ -390,7 +317,7 @@ public:
 
 protected:
     /// Returns the value of query from the backend API blocking as needed.
-    virtual u64 BlockingQuery(bool async = false) const = 0;
+    virtual u64 BlockingQuery() const = 0;
 
 private:
     std::shared_ptr<HostCounter> dependency; ///< Counter to add to this value.
@@ -413,33 +340,26 @@ public:
     CachedQueryBase& operator=(const CachedQueryBase&) = delete;
 
     /// Flushes the query to guest memory.
-    virtual u64 Flush(bool async = false) {
+    virtual void Flush() {
         // When counter is nullptr it means that it's just been reset. We are supposed to write a
         // zero in these cases.
-        const u64 value = counter ? counter->Query(async) : 0;
-        if (async) {
-            return value;
-        }
+        const u64 value = counter ? counter->Query() : 0;
         std::memcpy(host_ptr, &value, sizeof(u64));
 
         if (timestamp) {
             std::memcpy(host_ptr + TIMESTAMP_OFFSET, &*timestamp, sizeof(u64));
         }
-        return value;
     }
 
     /// Binds a counter to this query.
-    std::optional<u64> BindCounter(std::shared_ptr<HostCounter> counter_,
-                                   std::optional<u64> timestamp_) {
-        std::optional<u64> result{};
+    void BindCounter(std::shared_ptr<HostCounter> counter_, std::optional<u64> timestamp_) {
         if (counter) {
             // If there's an old counter set it means the query is being rewritten by the game.
             // To avoid losing the data forever, flush here.
-            result = std::make_optional(Flush());
+            Flush();
         }
         counter = std::move(counter_);
         timestamp = timestamp_;
-        return result;
     }
 
     VAddr GetCpuAddr() const noexcept {
@@ -454,14 +374,6 @@ public:
         return with_timestamp ? LARGE_QUERY_SIZE : SMALL_QUERY_SIZE;
     }
 
-    void SetAsyncJob(AsyncJobId assigned_async_job_) {
-        assigned_async_job = assigned_async_job_;
-    }
-
-    AsyncJobId GetAsyncJob() const {
-        return assigned_async_job;
-    }
-
 protected:
     /// Returns true when querying the counter may potentially block.
     bool WaitPending() const noexcept {
@@ -477,7 +389,6 @@ private:
     u8* host_ptr;                         ///< Writable host pointer.
     std::shared_ptr<HostCounter> counter; ///< Host counter to query, owns the dependency tree.
     std::optional<u64> timestamp;         ///< Timestamp to flush to guest memory.
-    AsyncJobId assigned_async_job;
 };
 
 } // namespace VideoCommon

src/video_core/renderer_opengl/gl_fence_manager.h

@@ -30,17 +30,7 @@ private:
 };
 
 using Fence = std::shared_ptr<GLInnerFence>;
-
-struct FenceManagerParams {
-    using FenceType = Fence;
-    using BufferCacheType = BufferCache;
-    using TextureCacheType = TextureCache;
-    using QueryCacheType = QueryCache;
-
-    static constexpr bool HAS_ASYNC_CHECK = false;
-};
-
-using GenericFenceManager = VideoCommon::FenceManager<FenceManagerParams>;
+using GenericFenceManager = VideoCommon::FenceManager<Fence, TextureCache, BufferCache, QueryCache>;
 
 class FenceManagerOpenGL final : public GenericFenceManager {
 public:

src/video_core/renderer_opengl/gl_query_cache.cpp

@@ -26,8 +26,8 @@ constexpr GLenum GetTarget(VideoCore::QueryType type) {
 
 } // Anonymous namespace
 
-QueryCache::QueryCache(RasterizerOpenGL& rasterizer_, Core::Memory::Memory& cpu_memory_)
-    : QueryCacheBase(rasterizer_, cpu_memory_), gl_rasterizer{rasterizer_} {}
+QueryCache::QueryCache(RasterizerOpenGL& rasterizer_)
+    : QueryCacheBase(rasterizer_), gl_rasterizer{rasterizer_} {}
 
 QueryCache::~QueryCache() = default;
 
@@ -74,7 +74,7 @@ void HostCounter::EndQuery() {
     glEndQuery(GetTarget(type));
 }
 
-u64 HostCounter::BlockingQuery([[maybe_unused]] bool async) const {
+u64 HostCounter::BlockingQuery() const {
     GLint64 value;
     glGetQueryObjecti64v(query.handle, GL_QUERY_RESULT, &value);
     return static_cast<u64>(value);
@@ -96,7 +96,7 @@ CachedQuery& CachedQuery::operator=(CachedQuery&& rhs) noexcept {
     return *this;
 }
 
-u64 CachedQuery::Flush([[maybe_unused]] bool async) {
+void CachedQuery::Flush() {
     // Waiting for a query while another query of the same target is enabled locks Nvidia's driver.
     // To avoid this disable and re-enable keeping the dependency stream.
     // But we only have to do this if we have pending waits to be done.
@@ -106,13 +106,11 @@ u64 CachedQuery::Flush([[maybe_unused]] bool async) {
         stream.Update(false);
     }
 
-    auto result = VideoCommon::CachedQueryBase<HostCounter>::Flush();
+    VideoCommon::CachedQueryBase<HostCounter>::Flush();
 
     if (slice_counter) {
         stream.Update(true);
     }
-
-    return result;
 }
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_query_cache.h

@@ -28,7 +28,7 @@ using CounterStream = VideoCommon::CounterStreamBase<QueryCache, HostCounter>;
 class QueryCache final
     : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit QueryCache(RasterizerOpenGL& rasterizer_, Core::Memory::Memory& cpu_memory_);
+    explicit QueryCache(RasterizerOpenGL& rasterizer_);
     ~QueryCache();
 
     OGLQuery AllocateQuery(VideoCore::QueryType type);
@@ -51,7 +51,7 @@ public:
     void EndQuery();
 
 private:
-    u64 BlockingQuery(bool async = false) const override;
+    u64 BlockingQuery() const override;
 
     QueryCache& cache;
     const VideoCore::QueryType type;
@@ -70,7 +70,7 @@ public:
     CachedQuery(const CachedQuery&) = delete;
     CachedQuery& operator=(const CachedQuery&) = delete;
 
-    u64 Flush(bool async = false) override;
+    void Flush() override;
 
 private:
     QueryCache* cache;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -63,7 +63,7 @@ RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra
       buffer_cache(*this, cpu_memory_, buffer_cache_runtime),
       shader_cache(*this, emu_window_, device, texture_cache, buffer_cache, program_manager,
                    state_tracker, gpu.ShaderNotify()),
-      query_cache(*this, cpu_memory_), accelerate_dma(buffer_cache, texture_cache),
+      query_cache(*this), accelerate_dma(buffer_cache, texture_cache),
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache),
       blit_image(program_manager_) {}
 

src/video_core/renderer_vulkan/vk_fence_manager.cpp

@@ -5,7 +5,6 @@
 
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
-#include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/vulkan_common/vulkan_device.h"

src/video_core/renderer_vulkan/vk_fence_manager.h

@@ -40,16 +40,7 @@ private:
 };
 using Fence = std::shared_ptr<InnerFence>;
 
-struct FenceManagerParams {
-    using FenceType = Fence;
-    using BufferCacheType = BufferCache;
-    using TextureCacheType = TextureCache;
-    using QueryCacheType = QueryCache;
-
-    static constexpr bool HAS_ASYNC_CHECK = true;
-};
-
-using GenericFenceManager = VideoCommon::FenceManager<FenceManagerParams>;
+using GenericFenceManager = VideoCommon::FenceManager<Fence, TextureCache, BufferCache, QueryCache>;
 
 class FenceManager final : public GenericFenceManager {
 public:

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -66,10 +66,9 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {
     }
 }
 
-QueryCache::QueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                       Core::Memory::Memory& cpu_memory_, const Device& device_,
+QueryCache::QueryCache(VideoCore::RasterizerInterface& rasterizer_, const Device& device_,
                        Scheduler& scheduler_)
-    : QueryCacheBase{rasterizer_, cpu_memory_}, device{device_}, scheduler{scheduler_},
+    : QueryCacheBase{rasterizer_}, device{device_}, scheduler{scheduler_},
       query_pools{
           QueryPool{device_, scheduler_, QueryType::SamplesPassed},
       } {}
@@ -99,10 +98,8 @@ HostCounter::HostCounter(QueryCache& cache_, std::shared_ptr<HostCounter> depend
       query{cache_.AllocateQuery(type_)}, tick{cache_.GetScheduler().CurrentTick()} {
     const vk::Device* logical = &cache.GetDevice().GetLogical();
     cache.GetScheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
-        const bool use_precise = Settings::IsGPULevelHigh();
         logical->ResetQueryPool(query.first, query.second, 1);
-        cmdbuf.BeginQuery(query.first, query.second,
-                          use_precise ? VK_QUERY_CONTROL_PRECISE_BIT : 0);
+        cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT);
     });
 }
 
@@ -115,10 +112,8 @@ void HostCounter::EndQuery() {
         [query = query](vk::CommandBuffer cmdbuf) { cmdbuf.EndQuery(query.first, query.second); });
 }
 
-u64 HostCounter::BlockingQuery(bool async) const {
-    if (!async) {
-        cache.GetScheduler().Wait(tick);
-    }
+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),

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -52,8 +52,7 @@ private:
 class QueryCache final
     : public VideoCommon::QueryCacheBase<QueryCache, CachedQuery, CounterStream, HostCounter> {
 public:
-    explicit QueryCache(VideoCore::RasterizerInterface& rasterizer_,
-                        Core::Memory::Memory& cpu_memory_, const Device& device_,
+    explicit QueryCache(VideoCore::RasterizerInterface& rasterizer_, const Device& device_,
                         Scheduler& scheduler_);
     ~QueryCache();
 
@@ -84,7 +83,7 @@ public:
     void EndQuery();
 
 private:
-    u64 BlockingQuery(bool async = false) const override;
+    u64 BlockingQuery() const override;
 
     QueryCache& cache;
     const VideoCore::QueryType type;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -172,8 +172,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
       buffer_cache(*this, cpu_memory_, buffer_cache_runtime),
       pipeline_cache(*this, device, scheduler, descriptor_pool, update_descriptor_queue,
                      render_pass_cache, buffer_cache, texture_cache, gpu.ShaderNotify()),
-      query_cache{*this, cpu_memory_, device, scheduler},
-      accelerate_dma(buffer_cache, texture_cache, scheduler),
+      query_cache{*this, device, scheduler}, accelerate_dma(buffer_cache, texture_cache, scheduler),
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
@@ -676,8 +675,7 @@ bool RasterizerVulkan::AccelerateConditionalRendering() {
     const GPUVAddr condition_address{maxwell3d->regs.render_enable.Address()};
     Maxwell::ReportSemaphore::Compare cmp;
     if (gpu_memory->IsMemoryDirty(condition_address, sizeof(cmp),
-                                  VideoCommon::CacheType::BufferCache |
-                                      VideoCommon::CacheType::QueryCache)) {
+                                  VideoCommon::CacheType::BufferCache)) {
         return true;
     }
     return false;

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -65,6 +65,18 @@ VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, u32 wi
     return extent;
 }
 
+VkCompositeAlphaFlagBitsKHR ChooseAlphaFlags(const VkSurfaceCapabilitiesKHR& capabilities) {
+    if (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) {
+        return VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    } else if (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
+        return VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    } else {
+        LOG_ERROR(Render_Vulkan, "Unknown composite alpha flags value {:#x}",
+                  capabilities.supportedCompositeAlpha);
+        return VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    }
+}
+
 } // Anonymous namespace
 
 Swapchain::Swapchain(VkSurfaceKHR surface_, const Device& device_, Scheduler& scheduler_,
@@ -155,6 +167,7 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bo
     const auto formats{physical_device.GetSurfaceFormatsKHR(surface)};
     const auto present_modes{physical_device.GetSurfacePresentModesKHR(surface)};
 
+    const VkCompositeAlphaFlagBitsKHR alpha_flags{ChooseAlphaFlags(capabilities)};
     const VkSurfaceFormatKHR surface_format{ChooseSwapSurfaceFormat(formats)};
     present_mode = ChooseSwapPresentMode(present_modes);
 
@@ -185,7 +198,7 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bo
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices = nullptr,
         .preTransform = capabilities.currentTransform,
-        .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+        .compositeAlpha = alpha_flags,
         .presentMode = present_mode,
         .clipped = VK_FALSE,
         .oldSwapchain = nullptr,