Merge pull request #21 from aaaapai/ankerl

Update AstcDecompressor.cpp

Author: aaaapai

include/ankerl/stl.h

@@ -29,6 +29,7 @@
 #ifndef ANKERL_STL_H
 #define ANKERL_STL_H
 
+#include <cstdlib>
 #include <array>            // for array
 #include <cstdint>          // for uint64_t, uint32_t, std::uint8_t, UINT64_C
 #include <cstring>          // for size_t, memcpy, memset

out/Android-arm64/args.gn

@@ -40,6 +40,7 @@ use_lto = true
 angle_build_tests = false
 
 cflags_c = [
+  "-Wno-unsafe-buffer-usage",
   "-Wno-unused-variable",
   "-Wno-error=unused-variable",
   "-Wno-error",
@@ -81,6 +82,7 @@ cflags_c = [
 ]
 
 cflags_cc = [
+  "-Wno-unsafe-buffer-usage",
   "-Wno-unused-variable",
   "-Wno-error=unused-variable",
   "-Wno-error",

src/common/base/anglebase/containers/mru_cache.h

@@ -28,6 +28,9 @@
 #include "anglebase/logging.h"
 #include "anglebase/macros.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace angle
 {
 
@@ -247,7 +250,7 @@ class MRUCache : public MRUCacheBase<KeyType, PayloadType, CompareType>
 template <class KeyType, class ValueType, class HashType>
 struct MRUCacheHashMap
 {
-    typedef std::unordered_map<KeyType, ValueType, HashType> Type;
+    typedef ankerl::unordered_dense::map<KeyType, ValueType, HashType> Type;
 };
 
 // This class is similar to MRUCache, except that it uses std::unordered_map as

src/common/hash_containers.h

@@ -9,12 +9,16 @@
 #ifndef COMMON_HASH_CONTAINERS_H_
 #define COMMON_HASH_CONTAINERS_H_
 
+//#undef ANGLE_USE_ABSEIL // Is ABSEIL faster?
+
 #if defined(ANGLE_USE_ABSEIL)
 #    include "absl/container/flat_hash_map.h"
 #    include "absl/container/flat_hash_set.h"
 #else
 #    include <unordered_map>
 #    include <unordered_set>
+#    include <ankerl/stl.h>
+#    include <ankerl/unordered_dense.h>
 #endif  // defined(ANGLE_USE_ABSEIL)
 
 namespace angle
@@ -38,9 +42,9 @@ template <typename Key,
           typename T,
           class Hash     = std::hash<Key>,
           class KeyEqual = std::equal_to<Key>>
-using HashMap = std::unordered_map<Key, T, Hash, KeyEqual>;
+using HashMap = ankerl::unordered_dense::map<Key, T, Hash, KeyEqual>;
 template <typename Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
-using HashSet = std::unordered_set<Key, Hash, KeyEqual>;
+using HashSet = ankerl::unordered_dense::set<Key, Hash, KeyEqual>;
 #    if __cpp_lib_generic_unordered_lookup >= 201811L
 #        define ANGLE_HAS_HASH_MAP_GENERIC_LOOKUP 1
 #    else

src/image_util/AstcDecompressor.cpp

@@ -15,6 +15,9 @@
 #include "common/WorkerThread.h"
 #include "image_util/AstcDecompressor.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace angle
 {
 namespace
@@ -135,7 +138,7 @@ class AstcDecompressorContextCache
         }
     };
 
-    std::unordered_map<Key, Value, KeyHash> mContexts;
+    ankerl::unordered_dense::map<Key, Value, KeyHash> mContexts;
 };
 
 struct DecompressTask : public Closure

src/image_util/storeimage_paletted.cpp

@@ -19,6 +19,9 @@
 
 #include "image_util/imageformats.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace angle
 {
 
@@ -115,7 +118,7 @@ void StoreRGBA8ToPalettedImpl(size_t width,
                               size_t outputRowPitch,
                               size_t outputDepthPitch)
 {
-    std::unordered_map<uint32_t, size_t> invPalette;
+    ankerl::unordered_dense::map<uint32_t, size_t> invPalette;
 
     ASSERT((redBlueBits + greenBits + redBlueBits + alphaBits) % 8 == 0);
 

src/libANGLE/renderer/vulkan/MemoryTracking.h

@@ -19,6 +19,9 @@
 #include "common/hash_containers.h"
 #include "common/vulkan/vk_headers.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace rx
 {
 namespace vk
@@ -224,7 +227,7 @@ class MemoryAllocationTracker : angle::NonCopyable
     // allocation ID and a record of all active allocations.
     uint64_t mMemoryAllocationID;
     using MemoryAllocInfoMap = angle::HashMap<vk::MemoryAllocInfoMapKey, vk::MemoryAllocationInfo>;
-    std::unordered_map<angle::BacktraceInfo, MemoryAllocInfoMap> mMemoryAllocationRecord;
+    ankerl::unordered_dense::map<angle::BacktraceInfo, MemoryAllocInfoMap> mMemoryAllocationRecord;
 };
 }  // namespace rx
 

src/libANGLE/renderer/vulkan/UtilsVk.h

@@ -33,6 +33,9 @@
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 #include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace rx
 {
 class UtilsVk : angle::NonCopyable

src/libANGLE/renderer/vulkan/vk_cache_utils.h

@@ -26,6 +26,9 @@
 #include "libANGLE/renderer/vulkan/vk_resource.h"
 #include "libANGLE/renderer/vulkan/vk_utils.h"
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace gl
 {
 class ProgramExecutable;
@@ -2668,8 +2671,8 @@ class RenderPassCache final : angle::NonCopyable
     // Use a two-layer caching scheme. The top level matches the "compatible" RenderPass elements.
     // The second layer caches the attachment load/store ops and initial/final layout.
     // Switch to `std::unordered_map` to retain pointer stability.
-    using InnerCache = std::unordered_map<vk::AttachmentOpsArray, vk::RenderPassHelper>;
-    using OuterCache = std::unordered_map<vk::RenderPassDesc, InnerCache>;
+    using InnerCache = ankerl::unordered_dense::map<vk::AttachmentOpsArray, vk::RenderPassHelper>;
+    using OuterCache = ankerl::unordered_dense::map<vk::RenderPassDesc, InnerCache>;
 
     OuterCache mPayload;
     CacheStats mCompatibleRenderPassCacheStats;
@@ -2870,7 +2873,7 @@ class DescriptorSetLayoutCache final : angle::NonCopyable
 
   private:
     mutable angle::SimpleMutex mMutex;
-    std::unordered_map<vk::DescriptorSetLayoutDesc, vk::DescriptorSetLayoutPtr> mPayload;
+    ankerl::unordered_dense::map<vk::DescriptorSetLayoutDesc, vk::DescriptorSetLayoutPtr> mPayload;
     CacheStats mCacheStats;
 };
 
@@ -2889,7 +2892,7 @@ class PipelineLayoutCache final : public HasCacheStats<VulkanCacheType::Pipeline
 
   private:
     mutable angle::SimpleMutex mMutex;
-    std::unordered_map<vk::PipelineLayoutDesc, vk::PipelineLayoutPtr> mPayload;
+    ankerl::unordered_dense::map<vk::PipelineLayoutDesc, vk::PipelineLayoutPtr> mPayload;
 };
 
 class SamplerCache final : public HasCacheStats<VulkanCacheType::Sampler>
@@ -2905,7 +2908,7 @@ class SamplerCache final : public HasCacheStats<VulkanCacheType::Sampler>
                              vk::SharedSamplerPtr *samplerOut);
 
   private:
-    std::unordered_map<vk::SamplerDesc, vk::SharedSamplerPtr> mPayload;
+    ankerl::unordered_dense::map<vk::SamplerDesc, vk::SharedSamplerPtr> mPayload;
 };
 
 // YuvConversion Cache
@@ -2924,7 +2927,7 @@ class SamplerYcbcrConversionCache final
 
   private:
     using SamplerYcbcrConversionMap =
-        std::unordered_map<vk::YcbcrConversionDesc, vk::SamplerYcbcrConversion>;
+        ankerl::unordered_dense::map<vk::YcbcrConversionDesc, vk::SamplerYcbcrConversion>;
     SamplerYcbcrConversionMap mExternalFormatPayload;
     SamplerYcbcrConversionMap mVkFormatPayload;
 };

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -24,6 +24,9 @@
 
 #include <functional>
 
+#include <ankerl/stl.h>
+#include <ankerl/unordered_dense.h>
+
 namespace gl
 {
 class ImageIndex;
@@ -476,7 +479,7 @@ class MetaDescriptorPool final : angle::NonCopyable
     }
 
   private:
-    std::unordered_map<DescriptorSetLayoutDesc, DynamicDescriptorPoolPointer> mPayload;
+    ankerl::unordered_dense::map<DescriptorSetLayoutDesc, DynamicDescriptorPoolPointer> mPayload;
 };
 
 template <typename Pool>