vk: testing a robin_map key hash failure

Executable on device with:

./build.sh -p android -q arm64-v8a release test_compiler && adb push out/cmake-android-release-aarch64/filament/test/test_compiler /data/local/tmp/ && adb shell chmod 777 /data/local/tmp/test_compiler && adb shell /data/local/tmp/test_compiler

CMakeLists.txt

@@ -746,7 +746,6 @@ add_subdirectory(${EXTERNAL}/draco/tnt)
 add_subdirectory(${EXTERNAL}/jsmn/tnt)
 add_subdirectory(${EXTERNAL}/stb/tnt)
 add_subdirectory(${EXTERNAL}/getopt)
-add_subdirectory(${EXTERNAL}/unordered_dense)
 
 # Note that this has to be placed after mikktspace in order for combine_static_libs to work.
 add_subdirectory(${LIBRARIES}/geometry)

android/filament-android/CMakeLists.txt

@@ -128,6 +128,7 @@ target_include_directories(filament-jni PRIVATE
         ..
         ${FILAMENT_DIR}/include
         ../../filament/backend/include
+        ../../third_party/robin-map
         ../../libs/utils/include)
 
 # Force a relink when the version script is changed:

android/filament-android/src/main/cpp/Renderer.cpp

@@ -28,6 +28,14 @@
 using namespace filament;
 using namespace backend;
 
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_google_android_filament_Renderer_nSkipFrame(JNIEnv *, jclass, jlong nativeRenderer,
+        jlong vsyncSteadyClockTimeNano) {
+    Renderer *renderer = (Renderer *) nativeRenderer;
+    renderer->skipFrame(uint64_t(vsyncSteadyClockTimeNano));
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_google_android_filament_Renderer_nBeginFrame(JNIEnv *, jclass, jlong nativeRenderer,
         jlong nativeSwapChain, jlong frameTimeNanos) {

android/filament-android/src/main/cpp/View.cpp

@@ -531,3 +531,12 @@ Java_com_google_android_filament_View_nGetFogEntity(JNIEnv *env, jclass clazz,
     View *view = (View *) nativeView;
     return (jint)view->getFogEntity().getId();
 }
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_google_android_filament_View_nClearFrameHistory(JNIEnv *env, jclass clazz,
+        jlong nativeView, jlong nativeEngine) {
+    View *view = (View *) nativeView;
+    Engine *engine = (Engine *) nativeEngine;
+    view->clearFrameHistory(*engine);
+}

android/filament-android/src/main/java/com/google/android/filament/Engine.java

@@ -425,9 +425,12 @@ public class Engine {
         public long resourceAllocatorCacheSizeMB = 64;
 
         /*
-         * This value determines for how many frames are texture entries kept in the cache.
+         * This value determines how many frames texture entries are kept for in the cache. This
+         * is a soft limit, meaning some texture older than this are allowed to stay in the cache.
+         * Typically only one texture is evicted per frame.
+         * The default is 1.
          */
-        public long resourceAllocatorCacheMaxAge = 2;
+        public long resourceAllocatorCacheMaxAge = 1;
 
         /*
          * Disable backend handles use-after-free checks.

android/filament-android/src/main/java/com/google/android/filament/Renderer.java

@@ -297,6 +297,20 @@ public class Renderer {
         nSetVsyncTime(getNativeObject(), steadyClockTimeNano);
     }
 
+    /**
+     * Call skipFrame when momentarily skipping frames, for instance if the content of the
+     * scene doesn't change.
+     *
+     * @param vsyncSteadyClockTimeNano The time in nanoseconds when the frame started being rendered,
+     *                       in the {@link System#nanoTime()} timebase. Divide this value by 1000000 to
+     *                       convert it to the {@link android.os.SystemClock#uptimeMillis()}
+     *                       time base. This typically comes from
+     *                       {@link android.view.Choreographer.FrameCallback}.
+     */
+    public void skipFrame(long vsyncSteadyClockTimeNano) {
+        nSkipFrame(getNativeObject(), vsyncSteadyClockTimeNano);
+    }
+
     /**
      * Sets up a frame for this <code>Renderer</code>.
      * <p><code>beginFrame</code> manages frame pacing, and returns whether or not a frame should be
@@ -716,6 +730,7 @@ public class Renderer {
 
     private static native void nSetPresentationTime(long nativeObject, long monotonicClockNanos);
     private static native void nSetVsyncTime(long nativeObject, long steadyClockTimeNano);
+    private static native void nSkipFrame(long nativeObject, long vsyncSteadyClockTimeNano);
     private static native boolean nBeginFrame(long nativeRenderer, long nativeSwapChain, long frameTimeNanos);
     private static native void nEndFrame(long nativeRenderer);
     private static native void nRender(long nativeRenderer, long nativeView);

android/filament-android/src/main/java/com/google/android/filament/View.java

@@ -1233,6 +1233,18 @@ public class View {
         return nGetFogEntity(getNativeObject());
     }
 
+    /**
+     * When certain temporal features are used (e.g.: TAA or Screen-space reflections), the view
+     * keeps a history of previous frame renders associated with the Renderer the view was last
+     * used with. When switching Renderer, it may be necessary to clear that history by calling
+     * this method. Similarly, if the whole content of the screen change, like when a cut-scene
+     * starts, clearing the history might be needed to avoid artifacts due to the previous frame
+     * being very different.
+     */
+    public void clearFrameHistory(Engine engine) {
+        nClearFrameHistory(getNativeObject(), engine.getNativeObject());
+    }
+
     public long getNativeObject() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Calling method on destroyed View");
@@ -1294,7 +1306,7 @@ public class View {
     private static native void nSetMaterialGlobal(long nativeView, int index, float x, float y, float z, float w);
     private static native void nGetMaterialGlobal(long nativeView, int index, float[] out);
     private static native int nGetFogEntity(long nativeView);
-
+    private static native void nClearFrameHistory(long nativeView, long nativeEngine);
 
     /**
      * List of available ambient occlusion techniques.

filament/backend/CMakeLists.txt

@@ -313,7 +313,6 @@ endif()
 
 target_link_libraries(${TARGET} PUBLIC math)
 target_link_libraries(${TARGET} PUBLIC utils)
-target_link_libraries(${TARGET} PRIVATE unordered_dense)
 
 # Android, iOS, and WebGL do not use bluegl.
 if(FILAMENT_SUPPORTS_OPENGL AND NOT IOS AND NOT ANDROID AND NOT WEBGL)

filament/backend/src/vulkan/VulkanPipelineCache.cpp

@@ -53,7 +53,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::getOrCreatePipelin
     // If a cached object exists, re-use it, otherwise create a new one.
     if (PipelineMap::iterator pipelineIter = mPipelines.find(mPipelineRequirements);
             pipelineIter != mPipelines.end()) {
-        auto& pipeline = pipelineIter->second;
+        auto& pipeline = pipelineIter.value();
         pipeline.lastUsed = mCurrentTime;
         return &pipeline;
     }
@@ -242,7 +242,7 @@ VulkanPipelineCache::PipelineCacheEntry* VulkanPipelineCache::createPipeline() n
         return nullptr;
     }
 
-    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first->second;
+    return &mPipelines.emplace(mPipelineRequirements, cacheEntry).first.value();
 }
 
 void VulkanPipelineCache::bindProgram(VulkanProgram* program) noexcept {
@@ -310,7 +310,7 @@ void VulkanPipelineCache::gc() noexcept {
     // Any pipeline older than FVK_MAX_COMMAND_BUFFERS can be safely destroyed.
    using ConstPipeIterator = decltype(mPipelines)::const_iterator;
    for (ConstPipeIterator iter = mPipelines.begin(); iter != mPipelines.end();) {
-       const PipelineCacheEntry& cacheEntry = iter->second;
+       const PipelineCacheEntry& cacheEntry = iter.value();
        if (cacheEntry.lastUsed + FVK_MAX_PIPELINE_AGE < mCurrentTime) {
            vkDestroyPipeline(mDevice, iter->second.handle, VKALLOC);
            iter = mPipelines.erase(iter);

filament/backend/src/vulkan/VulkanPipelineCache.h

@@ -33,11 +33,11 @@
 #include <utils/compiler.h>
 #include <utils/Hash.h>
 
-#include <ankerl/unordered_dense.h>
-
 #include <list>
+#include <tsl/robin_map.h>
 #include <type_traits>
 #include <vector>
+#include <unordered_map>
 
 namespace filament::backend {
 
@@ -238,10 +238,7 @@ private:
     // CACHE CONTAINERS
     // ----------------
 
-//    using PipelineMap = tsl::robin_map<PipelineKey, PipelineCacheEntry,
-//            PipelineHashFn, PipelineEqual>;
-
-    using PipelineMap = ankerl::unordered_dense::map<PipelineKey, PipelineCacheEntry,
+    using PipelineMap = tsl::robin_map<PipelineKey, PipelineCacheEntry,
             PipelineHashFn, PipelineEqual>;
 
 private:

filament/backend/src/vulkan/caching/VulkanPipelineLayoutCache.cpp

@@ -53,7 +53,7 @@ VkPipelineLayout VulkanPipelineLayoutCache::getLayout(
     }
 
     if (PipelineLayoutMap::iterator iter = mPipelineLayouts.find(key); iter != mPipelineLayouts.end()) {
-        PipelineLayoutCacheEntry& entry = iter->second;
+        PipelineLayoutCacheEntry& entry = iter.value();
         entry.lastUsed = mTimestamp++;
         return entry.handle;
     }

filament/backend/src/vulkan/caching/VulkanPipelineLayoutCache.h

@@ -23,7 +23,6 @@
 #include <utils/Hash.h>
 
 #include <tsl/robin_map.h>
-#include <ankerl/unordered_dense.h>
 
 namespace filament::backend {
 
@@ -74,10 +73,7 @@ private:
         }
     };
 
-//    using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey, PipelineLayoutCacheEntry,
-//            PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
-
-    using PipelineLayoutMap = ankerl::unordered_dense::map<PipelineLayoutKey, PipelineLayoutCacheEntry,
+    using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey, PipelineLayoutCacheEntry,
             PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
 
     VkDevice mDevice;

filament/include/filament/Engine.h

@@ -350,9 +350,12 @@ public:
         uint32_t resourceAllocatorCacheSizeMB = 64;
 
         /*
-         * This value determines for how many frames are texture entries kept in the cache.
+         * This value determines how many frames texture entries are kept for in the cache. This
+         * is a soft limit, meaning some texture older than this are allowed to stay in the cache.
+         * Typically only one texture is evicted per frame.
+         * The default is 1.
          */
-        uint32_t resourceAllocatorCacheMaxAge = 2;
+        uint32_t resourceAllocatorCacheMaxAge = 1;
 
         /*
          * Disable backend handles use-after-free checks.

filament/include/filament/Renderer.h

@@ -271,6 +271,14 @@ public:
      */
     void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
 
+    /**
+     * Call skipFrame when momentarily skipping frames, for instance if the content of the
+     * scene doesn't change.
+     *
+     * @param vsyncSteadyClockTimeNano
+     */
+    void skipFrame(uint64_t vsyncSteadyClockTimeNano = 0u);
+
     /**
      * Set-up a frame for this Renderer.
      *

filament/include/filament/View.h

@@ -40,6 +40,7 @@ class CallbackHandler;
 
 class Camera;
 class ColorGrading;
+class Engine;
 class MaterialInstance;
 class RenderTarget;
 class Scene;
@@ -878,6 +879,17 @@ public:
      */
     utils::Entity getFogEntity() const noexcept;
 
+
+    /**
+     * When certain temporal features are used (e.g.: TAA or Screen-space reflections), the view
+     * keeps a history of previous frame renders associated with the Renderer the view was last
+     * used with. When switching Renderer, it may be necessary to clear that history by calling
+     * this method. Similarly, if the whole content of the screen change, like when a cut-scene
+     * starts, clearing the history might be needed to avoid artifacts due to the previous frame
+     * being very different.
+     */
+    void clearFrameHistory(Engine& engine) noexcept;
+
     /**
      * List of available ambient occlusion techniques
      * @deprecated use AmbientOcclusionOptions::enabled instead

filament/src/FrameHistory.h

@@ -21,6 +21,9 @@
 #include <fg/FrameGraphTexture.h>
 
 #include <math/mat4.h>
+#include <math/vec2.h>
+
+#include <stdint.h>
 
 namespace filament {
 

filament/src/Renderer.cpp

@@ -45,6 +45,10 @@ void Renderer::setPresentationTime(int64_t monotonic_clock_ns) {
     downcast(this)->setPresentationTime(monotonic_clock_ns);
 }
 
+void Renderer::skipFrame(uint64_t vsyncSteadyClockTimeNano) {
+    downcast(this)->skipFrame(vsyncSteadyClockTimeNano);
+}
+
 bool Renderer::beginFrame(SwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano) {
     return downcast(this)->beginFrame(downcast(swapChain), vsyncSteadyClockTimeNano);
 }

filament/src/RendererUtils.cpp

@@ -172,7 +172,7 @@ FrameGraphId<FrameGraphTexture> RendererUtils::colorPass(
 
                 data.color = builder.write(data.color, FrameGraphTexture::Usage::COLOR_ATTACHMENT);
                 data.depth = builder.write(data.depth, FrameGraphTexture::Usage::DEPTH_ATTACHMENT);
-                if (engine.getConfig().stereoscopicType == StereoscopicType::MULTIVIEW) {
+                if (view.hasStereo() && engine.getConfig().stereoscopicType == StereoscopicType::MULTIVIEW) {
                     layerCount = engine.getConfig().stereoscopicEyeCount;
                 }
 

filament/src/ResourceAllocator.cpp

@@ -27,15 +27,18 @@
 
 #include "private/backend/DriverApi.h"
 
+#include <utils/algorithm.h>
+#include <utils/bitset.h>
 #include <utils/compiler.h>
 #include <utils/debug.h>
-#include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
 #include <utils/ostream.h>
 
 #include <array>
 #include <algorithm>
 #include <iterator>
+#include <memory>
+#include <optional>
 #include <utility>
 
 #include <stddef.h>
@@ -89,8 +92,15 @@ void ResourceAllocator::AssociativeContainer<K, V, H>::emplace(ARGS&& ... args)
 }
 
 // ------------------------------------------------------------------------------------------------
+
 ResourceAllocatorInterface::~ResourceAllocatorInterface() = default;
 
+// ------------------------------------------------------------------------------------------------
+
+ResourceAllocatorDisposerInterface::~ResourceAllocatorDisposerInterface() = default;
+
+// ------------------------------------------------------------------------------------------------
+
 size_t ResourceAllocator::TextureKey::getSize() const noexcept {
     size_t const pixelCount = width * height * depth;
     size_t size = pixelCount * FTexture::getFormatSize(format);
@@ -110,16 +120,22 @@ size_t ResourceAllocator::TextureKey::getSize() const noexcept {
 
 ResourceAllocator::ResourceAllocator(Engine::Config const& config, DriverApi& driverApi) noexcept
         : mCacheMaxAge(config.resourceAllocatorCacheMaxAge),
-          mBackend(driverApi) {
+          mBackend(driverApi),
+          mDisposer(std::make_shared<ResourceAllocatorDisposer>(driverApi)) {
+}
+
+ResourceAllocator::ResourceAllocator(std::shared_ptr<ResourceAllocatorDisposer> disposer,
+        Engine::Config const& config, DriverApi& driverApi) noexcept
+        : mCacheMaxAge(config.resourceAllocatorCacheMaxAge),
+          mBackend(driverApi),
+          mDisposer(std::move(disposer)) {
 }
 
 ResourceAllocator::~ResourceAllocator() noexcept {
-    assert_invariant(!mTextureCache.size());
-    assert_invariant(!mInUseTextures.size());
+    assert_invariant(mTextureCache.empty());
 }
 
 void ResourceAllocator::terminate() noexcept {
-    assert_invariant(!mInUseTextures.size());
     auto& textureCache = mTextureCache;
     for (auto it = textureCache.begin(); it != textureCache.end();) {
         mBackend.destroyTexture(it->second.handle);
@@ -174,7 +190,7 @@ backend::TextureHandle ResourceAllocator::createTexture(const char* name,
                         swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
             }
         }
-        mInUseTextures.emplace(handle, key);
+        mDisposer->checkout(handle, key);
     } else {
         if (swizzle == defaultSwizzle) {
             handle = mBackend.createTexture(
@@ -190,58 +206,99 @@ backend::TextureHandle ResourceAllocator::createTexture(const char* name,
 
 void ResourceAllocator::destroyTexture(TextureHandle h) noexcept {
     if constexpr (mEnabled) {
-        // find the texture in the in-use list (it must be there!)
-        auto it = mInUseTextures.find(h);
-        assert_invariant(it != mInUseTextures.end());
-
-        // move it to the cache
-        const TextureKey key = it->second;
-        uint32_t const size = key.getSize();
-
-        mTextureCache.emplace(key, TextureCachePayload{ h, mAge, size });
-        mCacheSize += size;
-
-        // remove it from the in-use list
-        mInUseTextures.erase(it);
+        auto const key = mDisposer->checkin(h);
+        if (UTILS_LIKELY(key.has_value())) {
+            uint32_t const size = key.value().getSize();
+            mTextureCache.emplace(key.value(), TextureCachePayload{ h, mAge, size });
+            mCacheSize += size;
+            mCacheSizeHiWaterMark = std::max(mCacheSizeHiWaterMark, mCacheSize);
+        }
     } else {
         mBackend.destroyTexture(h);
     }
 }
 
-void ResourceAllocator::gc() noexcept {
-    // this is called regularly -- usually once per frame of each Renderer
+ResourceAllocatorDisposerInterface& ResourceAllocator::getDisposer() noexcept {
+    return *mDisposer;
+}
 
-    // increase our age
-    const size_t age = mAge++;
+void ResourceAllocator::gc(bool skippedFrame) noexcept {
+    // this is called regularly -- usually once per frame
+
+    // increase our age at each (non-skipped) frame
+    const size_t age = mAge;
+    if (!skippedFrame) {
+        mAge++;
+    }
 
     // Purging strategy:
-    //  - remove entries that are older than a certain age
-    //      - remove only one entry per gc(),
+    //  - remove all entries older than MAX_AGE_SKIPPED_FRAME when skipping a frame
+    //  - remove entries older than mCacheMaxAgeSoft
+    //      - remove only MAX_EVICTION_COUNT entry per gc(),
+    //  - look for the number of unique resource ages present in the cache (this basically gives
+    //    us how many buckets of resources we have corresponding to previous frames.
+    //      - remove all resources that have an age older than the MAX_UNIQUE_AGE_COUNT'th bucket
 
     auto& textureCache = mTextureCache;
+
+    // when skipping a frame, the maximum age to keep in the cache
+    constexpr size_t MAX_AGE_SKIPPED_FRAME = 1;
+
+    // maximum entry count to evict per GC, under the mCacheMaxAgeSoft limit
+    constexpr size_t MAX_EVICTION_COUNT = 1;
+
+    // maximum number of unique ages in the cache
+    constexpr size_t MAX_UNIQUE_AGE_COUNT = 3;
+
+    utils::bitset32 ages;
+    uint32_t evictedCount = 0;
     for (auto it = textureCache.begin(); it != textureCache.end();) {
-        const size_t ageDiff = age - it->second.age;
-        if (ageDiff >= mCacheMaxAge) {
+        size_t const ageDiff = age - it->second.age;
+        if ((ageDiff >= MAX_AGE_SKIPPED_FRAME && skippedFrame) ||
+            (ageDiff >= mCacheMaxAge && evictedCount < MAX_EVICTION_COUNT)) {
+            evictedCount++;
             purge(it);
-            // only purge a single entry per gc
-            break;
         } else {
+            // build the set of ages present in the cache after eviction
+            ages.set(std::min(size_t(31), ageDiff));
             ++it;
         }
     }
+
+    // if we have MAX_UNIQUE_AGE_COUNT ages or more, we evict all the resources that
+    // are older than the MAX_UNIQUE_AGE_COUNT'th age.
+    if (!skippedFrame && ages.count() >= MAX_UNIQUE_AGE_COUNT) {
+        uint32_t bits = ages.getValue();
+        // remove from the set the ages we keep
+        for (size_t i = 0; i < MAX_UNIQUE_AGE_COUNT - 1; i++) {
+            bits &= ~(1 << utils::ctz(bits));
+        }
+        size_t const maxAge = utils::ctz(bits);
+        for (auto it = textureCache.begin(); it != textureCache.end();) {
+            const size_t ageDiff = age - it->second.age;
+            if (ageDiff >= maxAge) {
+                purge(it);
+            } else {
+                ++it;
+            }
+        }
+    }
 }
 
 UTILS_NOINLINE
 void ResourceAllocator::dump(bool brief) const noexcept {
-    slog.d << "# entries=" << mTextureCache.size() << ", sz=" << mCacheSize / float(1u << 20u)
-           << " MiB" << io::endl;
+    constexpr float MiB = 1.0f / float(1u << 20u);
+    slog.d  << "# entries=" << mTextureCache.size()
+            << ", sz=" << (float)mCacheSize * MiB << " MiB"
+            << ", max=" << (float)mCacheSizeHiWaterMark * MiB << " MiB"
+            << io::endl;
     if (!brief) {
         for (auto const& it : mTextureCache) {
             auto w = it.first.width;
             auto h = it.first.height;
             auto f = FTexture::getFormatSize(it.first.format);
             slog.d << it.first.name << ": w=" << w << ", h=" << h << ", f=" << f << ", sz="
-                   << it.second.size / float(1u << 20u) << io::endl;
+                   << (float)it.second.size * MiB << io::endl;
         }
     }
 }
@@ -254,4 +311,46 @@ void ResourceAllocator::purge(
     mTextureCache.erase(pos);
 }
 
+// ------------------------------------------------------------------------------------------------
+
+ResourceAllocatorDisposer::ResourceAllocatorDisposer(DriverApi& driverApi) noexcept
+        : mBackend(driverApi) {
+}
+
+ResourceAllocatorDisposer::~ResourceAllocatorDisposer() noexcept {
+     assert_invariant(mInUseTextures.empty());
+}
+
+void ResourceAllocatorDisposer::terminate() noexcept {
+    assert_invariant(mInUseTextures.empty());
+}
+
+void ResourceAllocatorDisposer::destroy(backend::TextureHandle handle) noexcept {
+    if (handle) {
+        auto r = checkin(handle);
+        if (r.has_value()) {
+            mBackend.destroyTexture(handle);
+        }
+    }
+}
+
+void ResourceAllocatorDisposer::checkout(backend::TextureHandle handle,
+        ResourceAllocator::TextureKey key) {
+    mInUseTextures.emplace(handle, key);
+}
+
+std::optional<ResourceAllocator::TextureKey> ResourceAllocatorDisposer::checkin(
+        backend::TextureHandle handle) {
+    // find the texture in the in-use list (it must be there!)
+    auto it = mInUseTextures.find(handle);
+    assert_invariant(it != mInUseTextures.end());
+    if (it == mInUseTextures.end()) {
+        return std::nullopt;
+    }
+    TextureKey const key = it->second;
+    // remove it from the in-use list
+    mInUseTextures.erase(it);
+    return key;
+}
+
 } // namespace filament

filament/src/ResourceAllocator.h

@@ -28,16 +28,29 @@
 #include <utils/Hash.h>
 
 #include <array>
-#include <vector>
+#include <memory>
+#include <optional>
 #include <utility>
+#include <vector>
 
+#include <cstddef>
 #include <stddef.h>
 #include <stdint.h>
 
 namespace filament {
 
+class ResourceAllocatorDisposer;
+
 // The only reason we use an interface here is for unit-tests, so we can mock this allocator.
 // This is not too time-critical, so that's okay.
+
+class ResourceAllocatorDisposerInterface {
+public:
+    virtual void destroy(backend::TextureHandle handle) noexcept = 0;
+protected:
+    virtual ~ResourceAllocatorDisposerInterface();
+};
+
 class ResourceAllocatorInterface {
 public:
     virtual backend::RenderTargetHandle createRenderTarget(const char* name,
@@ -60,15 +73,20 @@ public:
 
     virtual void destroyTexture(backend::TextureHandle h) noexcept = 0;
 
+    virtual ResourceAllocatorDisposerInterface& getDisposer() noexcept = 0;
+
 protected:
     virtual ~ResourceAllocatorInterface();
 };
 
-
 class ResourceAllocator final : public ResourceAllocatorInterface {
 public:
+    explicit ResourceAllocator(std::shared_ptr<ResourceAllocatorDisposer> disposer,
+            Engine::Config const& config, backend::DriverApi& driverApi) noexcept;
+
     explicit ResourceAllocator(
             Engine::Config const& config, backend::DriverApi& driverApi) noexcept;
+
     ~ResourceAllocator() noexcept override;
 
     void terminate() noexcept;
@@ -93,7 +111,9 @@ public:
 
     void destroyTexture(backend::TextureHandle h) noexcept override;
 
-    void gc() noexcept;
+    ResourceAllocatorDisposerInterface& getDisposer() noexcept override;
+
+    void gc(bool skippedFrame = false) noexcept;
 
 private:
     size_t const mCacheMaxAge;
@@ -181,6 +201,7 @@ private:
         using value_type = typename Container::value_type::second_type;
 
         size_t size() const { return mContainer.size(); }
+        bool empty() const { return size() == 0; }
         iterator begin() { return mContainer.begin(); }
         const_iterator begin() const { return mContainer.begin(); }
         iterator end() { return mContainer.end(); }
@@ -193,16 +214,36 @@ private:
     };
 
     using CacheContainer = AssociativeContainer<TextureKey, TextureCachePayload>;
-    using InUseContainer = AssociativeContainer<backend::TextureHandle, TextureKey>;
 
     void purge(ResourceAllocator::CacheContainer::iterator const& pos);
 
     backend::DriverApi& mBackend;
+    std::shared_ptr<ResourceAllocatorDisposer> mDisposer;
     CacheContainer mTextureCache;
-    InUseContainer mInUseTextures;
     size_t mAge = 0;
     uint32_t mCacheSize = 0;
+    uint32_t mCacheSizeHiWaterMark = 0;
     static constexpr bool mEnabled = true;
+
+    friend class ResourceAllocatorDisposer;
+};
+
+class ResourceAllocatorDisposer final : public ResourceAllocatorDisposerInterface {
+    using TextureKey = ResourceAllocator::TextureKey;
+public:
+    explicit ResourceAllocatorDisposer(backend::DriverApi& driverApi) noexcept;
+    ~ResourceAllocatorDisposer() noexcept override;
+    void terminate() noexcept;
+    void destroy(backend::TextureHandle handle) noexcept override;
+
+private:
+    friend class ResourceAllocator;
+    void checkout(backend::TextureHandle handle, TextureKey key);
+    std::optional<TextureKey> checkin(backend::TextureHandle handle);
+
+    using InUseContainer = ResourceAllocator::AssociativeContainer<backend::TextureHandle, TextureKey>;
+    backend::DriverApi& mBackend;
+    InUseContainer mInUseTextures;
 };
 
 } // namespace filament

filament/src/View.cpp

@@ -15,6 +15,8 @@
  */
 
 #include "details/View.h"
+#include "filament/View.h"
+
 
 namespace filament {
 
@@ -312,4 +314,8 @@ utils::Entity View::getFogEntity() const noexcept {
     return downcast(this)->getFogEntity();
 }
 
+void View::clearFrameHistory(Engine& engine) noexcept {
+    downcast(this)->clearFrameHistory(downcast(engine));
+}
+
 } // namespace filament

filament/src/details/Engine.cpp

@@ -163,8 +163,7 @@ FEngine* FEngine::getEngine(void* token) {
     FILAMENT_CHECK_PRECONDITION(ThreadUtils::isThisThread(instance->mMainThreadId))
             << "Engine::createAsync() and Engine::getEngine() must be called on the same thread.";
 
-    // we use mResourceAllocator as a proxy for "am I already initialized"
-    if (!instance->mResourceAllocator) {
+    if (!instance->mInitialized) {
         if (UTILS_UNLIKELY(!instance->mDriver)) {
             // something went horribly wrong during driver initialization
             instance->mDriverThread.join();
@@ -262,7 +261,7 @@ void FEngine::init() {
     slog.i << "FEngine feature level: " << int(mActiveFeatureLevel) << io::endl;
 
 
-    mResourceAllocator = new ResourceAllocator(mConfig, driverApi);
+    mResourceAllocatorDisposer = std::make_shared<ResourceAllocatorDisposer>(driverApi);
 
     mFullScreenTriangleVb = downcast(VertexBuffer::Builder()
             .vertexCount(3)
@@ -425,11 +424,13 @@ void FEngine::init() {
                     }
                 });
             });
+
+    mInitialized = true;
 }
 
 FEngine::~FEngine() noexcept {
     SYSTRACE_CALL();
-    delete mResourceAllocator;
+    assert_invariant(!mResourceAllocatorDisposer);
     delete mDriver;
     if (mOwnPlatform) {
         PlatformFactory::destroy(&mPlatform);
@@ -440,7 +441,7 @@ void FEngine::shutdown() {
     SYSTRACE_CALL();
 
     // by construction this should never be nullptr
-    assert_invariant(mResourceAllocator);
+    assert_invariant(mResourceAllocatorDisposer);
 
     FILAMENT_CHECK_PRECONDITION(ThreadUtils::isThisThread(mMainThreadId))
             << "Engine::shutdown() called from the wrong thread!";
@@ -460,7 +461,8 @@ void FEngine::shutdown() {
      */
 
     mPostProcessManager.terminate(driver);  // free-up post-process manager resources
-    mResourceAllocator->terminate();
+    mResourceAllocatorDisposer->terminate();
+    mResourceAllocatorDisposer.reset();
     mDFG.terminate(*this);                  // free-up the DFG
     mRenderableManager.terminate();         // free-up all renderables
     mLightManager.terminate();              // free-up all lights

filament/src/details/Engine.h

@@ -86,6 +86,7 @@ namespace filament {
 
 class Renderer;
 class MaterialParser;
+class ResourceAllocatorDisposer;
 
 namespace backend {
 class Driver;
@@ -254,9 +255,13 @@ public:
         }
     }
 
-    ResourceAllocator& getResourceAllocator() noexcept {
-        assert_invariant(mResourceAllocator);
-        return *mResourceAllocator;
+    ResourceAllocatorDisposer& getResourceAllocatorDisposer() noexcept {
+        assert_invariant(mResourceAllocatorDisposer);
+        return *mResourceAllocatorDisposer;
+    }
+
+    std::shared_ptr<ResourceAllocatorDisposer> const& getSharedResourceAllocatorDisposer() noexcept {
+        return mResourceAllocatorDisposer;
     }
 
     void* streamAlloc(size_t size, size_t alignment) noexcept;
@@ -490,7 +495,7 @@ private:
     FTransformManager mTransformManager;
     FLightManager mLightManager;
     FCameraManager mCameraManager;
-    ResourceAllocator* mResourceAllocator = nullptr;
+    std::shared_ptr<ResourceAllocatorDisposer> mResourceAllocatorDisposer;
     HwVertexBufferInfoFactory mHwVertexBufferInfoFactory;
 
     ResourceList<FBufferObject> mBufferObjects{ "BufferObject" };
@@ -562,6 +567,8 @@ private:
 
     std::thread::id mMainThreadId{};
 
+    bool mInitialized = false;
+
     // Creation parameters
     Config mConfig;
 

filament/src/details/Renderer.cpp

@@ -60,6 +60,7 @@
 
 #include <chrono>
 #include <limits>
+#include <memory>
 #include <utility>
 
 #include <stddef.h>
@@ -88,7 +89,11 @@ FRenderer::FRenderer(FEngine& engine) :
         mHdrQualityMedium(TextureFormat::R11F_G11F_B10F),
         mHdrQualityHigh(TextureFormat::RGB16F),
         mIsRGB8Supported(false),
-        mUserEpoch(engine.getEngineEpoch())
+        mUserEpoch(engine.getEngineEpoch()),
+        mResourceAllocator(std::make_unique<ResourceAllocator>(
+                engine.getSharedResourceAllocatorDisposer(),
+                engine.getConfig(),
+                engine.getDriverApi()))
 {
     FDebugRegistry& debugRegistry = engine.getDebugRegistry();
     debugRegistry.registerProperty("d.renderer.doFrameCapture",
@@ -176,6 +181,7 @@ void FRenderer::terminate(FEngine& engine) {
     }
     mFrameInfoManager.terminate(driver);
     mFrameSkipper.terminate(driver);
+    mResourceAllocator->terminate();
 }
 
 void FRenderer::resetUserTime() {
@@ -236,6 +242,39 @@ void FRenderer::setVsyncTime(uint64_t steadyClockTimeNano) noexcept {
     mVsyncSteadyClockTimeNano = steadyClockTimeNano;
 }
 
+void FRenderer::skipFrame(uint64_t vsyncSteadyClockTimeNano) {
+    SYSTRACE_CALL();
+
+    FILAMENT_CHECK_PRECONDITION(!mSwapChain) <<
+            "skipFrame() can't be called between beginFrame() and endFrame()";
+
+    if (!vsyncSteadyClockTimeNano) {
+        vsyncSteadyClockTimeNano = mVsyncSteadyClockTimeNano;
+        mVsyncSteadyClockTimeNano = 0;
+    }
+
+    FEngine& engine = mEngine;
+    FEngine::DriverApi& driver = engine.getDriverApi();
+
+    // Gives the backend a chance to execute periodic tasks. This must be called before
+    // the frame skipper.
+    driver.tick();
+
+    // do this before engine.flush()
+    mResourceAllocator->gc(true);
+
+    // Run the component managers' GC in parallel
+    // WARNING: while doing this we can't access any component manager
+    auto& js = engine.getJobSystem();
+
+    auto *job = js.runAndRetain(jobs::createJob(js, nullptr, &FEngine::gc, &engine)); // gc all managers
+
+    engine.flush();     // flush command stream
+
+    // make sure we're done with the gcs
+    js.waitAndRelease(job);
+}
+
 bool FRenderer::beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano) {
     assert_invariant(swapChain);
 
@@ -380,7 +419,7 @@ void FRenderer::endFrame() {
     }
 
     // do this before engine.flush()
-    engine.getResourceAllocator().gc();
+    mResourceAllocator->gc();
 
     // Run the component managers' GC in parallel
     // WARNING: while doing this we can't access any component manager
@@ -750,7 +789,7 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
      * Frame graph
      */
 
-    FrameGraph fg(engine.getResourceAllocator(),
+    FrameGraph fg(*mResourceAllocator,
             isProtectedContent ? FrameGraph::Mode::PROTECTED : FrameGraph::Mode::UNPROTECTED);
     auto& blackboard = fg.getBlackboard();
 

filament/src/details/Renderer.h

@@ -46,6 +46,7 @@
 #include <algorithm>
 #include <chrono>
 #include <functional>
+#include <memory>
 #include <utility>
 
 #include <stddef.h>
@@ -53,6 +54,8 @@
 
 namespace filament {
 
+class ResourceAllocator;
+
 namespace backend {
 class Driver;
 } // namespace backend
@@ -88,6 +91,9 @@ public:
 
     void setVsyncTime(uint64_t steadyClockTimeNano) noexcept;
 
+    // skip a frame
+    void skipFrame(uint64_t vsyncSteadyClockTimeNano);
+
     // start a frame
     bool beginFrame(FSwapChain* swapChain, uint64_t vsyncSteadyClockTimeNano);
 
@@ -206,6 +212,7 @@ private:
     tsl::robin_set<FRenderTarget*> mPreviousRenderTargets;
     std::function<void()> mBeginFrameInternal;
     uint64_t mVsyncSteadyClockTimeNano = 0;
+    std::unique_ptr<ResourceAllocator> mResourceAllocator{};
 };
 
 FILAMENT_DOWNCAST(Renderer)

filament/src/details/View.cpp

@@ -17,6 +17,7 @@
 #include "details/View.h"
 
 #include "Culler.h"
+#include "FrameHistory.h"
 #include "Froxelizer.h"
 #include "RenderPrimitive.h"
 #include "ResourceAllocator.h"
@@ -118,7 +119,7 @@ void FView::terminate(FEngine& engine) {
     DriverApi& driver = engine.getDriverApi();
     driver.destroyBufferObject(mLightUbh);
     driver.destroyBufferObject(mRenderableUbh);
-    drainFrameHistory(engine);
+    clearFrameHistory(engine);
 
     ShadowMapManager::terminate(engine, mShadowMapManager);
     mPerViewUniforms.terminate(driver);
@@ -1007,20 +1008,29 @@ FrameGraphId<FrameGraphTexture> FView::renderShadowMaps(FEngine& engine, FrameGr
 
 void FView::commitFrameHistory(FEngine& engine) noexcept {
     // Here we need to destroy resources in mFrameHistory.back()
+    auto& disposer = engine.getResourceAllocatorDisposer();
     auto& frameHistory = mFrameHistory;
 
     FrameHistoryEntry& last = frameHistory.back();
-    last.taa.color.destroy(engine.getResourceAllocator());
-    last.ssr.color.destroy(engine.getResourceAllocator());
+    disposer.destroy(last.taa.color.handle);
+    disposer.destroy(last.ssr.color.handle);
+    last.taa.color.handle.clear();
+    last.ssr.color.handle.clear();
 
     // and then push the new history entry to the history stack
     frameHistory.commit();
 }
 
-void FView::drainFrameHistory(FEngine& engine) noexcept {
+void FView::clearFrameHistory(FEngine& engine) noexcept {
     // make sure we free all resources in the history
-    for (size_t i = 0; i < mFrameHistory.size(); ++i) {
-        commitFrameHistory(engine);
+    auto& disposer = engine.getResourceAllocatorDisposer();
+    auto& frameHistory = mFrameHistory;
+    for (size_t i = 0; i < frameHistory.size(); ++i) {
+        FrameHistoryEntry& last = frameHistory[i];
+        disposer.destroy(last.taa.color.handle);
+        disposer.destroy(last.ssr.color.handle);
+        last.taa.color.handle.clear();
+        last.ssr.color.handle.clear();
     }
 }
 

filament/src/details/View.h

@@ -422,6 +422,10 @@ public:
     // (e.g.: after the FrameGraph execution).
     void commitFrameHistory(FEngine& engine) noexcept;
 
+    // Clean-up the whole history, free all resources. This is typically called when the View is
+    // being terminated. Or we're changing Renderer.
+    void clearFrameHistory(FEngine& engine) noexcept;
+
     // create the picking query
     View::PickingQuery& pick(uint32_t x, uint32_t y, backend::CallbackHandler* handler,
             View::PickingQueryResultCallback callback) noexcept;
@@ -485,10 +489,6 @@ private:
             Culler::result_type* visibleMask,
             size_t count);
 
-    // Clean-up the whole history, free all resources. This is typically called when the View is
-    // being terminated.
-    void drainFrameHistory(FEngine& engine) noexcept;
-
     // we don't inline this one, because the function is quite large and there is not much to
     // gain from inlining.
     static FScene::RenderableSoa::iterator partition(

filament/src/fg/FrameGraph.cpp

@@ -24,6 +24,7 @@
 #include "FrameGraphPass.h"
 #include "FrameGraphRenderPass.h"
 #include "FrameGraphTexture.h"
+#include "ResourceAllocator.h"
 
 #include "details/Engine.h"
 

filament/test/CMakeLists.txt

@@ -62,6 +62,7 @@ if (ANDROID)
     target_link_libraries(test_compiler PRIVATE utils)
     target_link_libraries(test_compiler PRIVATE EGL)
     target_link_libraries(test_compiler PRIVATE GLESv3)
+    target_link_libraries(test_compiler PRIVATE bluevk)    
 endif()
 
 add_executable(test_material_parser

filament/test/compiler_test.cpp

@@ -1,181 +1,82 @@
-/*
- * Copyright (C) 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+#include <iostream>
+#include <utils/Hash.h>
+#include <tsl/robin_map.h>
+#include <bluevk/BlueVK.h>
 
-#include <utils/Log.h>
+namespace {
 
-#include <GLES3/gl3.h>
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include <gtest/gtest.h>
-
-using namespace utils;
-using namespace std::literals;
-
-class CompilerTest : public testing::Test {
-protected:
-    void SetUp() override {
-        EGLBoolean success;
-        EGLint major, minor;
-        dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-        ASSERT_NE(dpy, EGL_NO_DISPLAY);
-
-        EGLBoolean const initialized = eglInitialize(dpy, &major, &minor);
-        ASSERT_TRUE(initialized);
-
-        EGLint const contextAttribs[] = {
-                EGL_CONTEXT_CLIENT_VERSION, 3,
-                EGL_NONE
-        };
-
-        EGLint configsCount;
-        EGLint configAttribs[] = {
-                EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,        //  0
-                EGL_RED_SIZE,    8,                                 //  2
-                EGL_GREEN_SIZE,  8,                                 //  4
-                EGL_BLUE_SIZE,   8,                                 //  6
-                EGL_NONE                                            // 14
-        };
-        success = eglChooseConfig(dpy, configAttribs, &config, 1, &configsCount);
-        ASSERT_TRUE(success);
-
-        context = eglCreateContext(dpy, config, EGL_NO_CONTEXT, contextAttribs);
-        ASSERT_NE(context, EGL_NO_CONTEXT);
-
-        success = eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, context);
-        ASSERT_TRUE(success);
-
-        ASSERT_EQ(eglGetError(), EGL_SUCCESS);
-    }
-
-    void TearDown() override {
-        eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-        eglDestroyContext(dpy, context);
-        eglTerminate(dpy);
-    }
-
-private:
-    EGLDisplay dpy;
-    EGLContext context;
-    EGLConfig config;
+struct T {
 };
 
-TEST_F(CompilerTest, Simple) {
-    auto shader = R"(
-#version 300 es
-void main()
-{
-})"sv;
+constexpr uint8_t const UNIQUE_DESCRIPTOR_SET_COUNT = 3;
+constexpr uint8_t const SHADER_TYPE_COUNT = 3;
+using Timestamp = uint64_t;
+using VulkanResourceAllocator = T;
 
-    const char* const src = shader.data();
-    GLint const len = (GLint)shader.size();
+struct PushConstantKey {
+    uint8_t stage;// We have one set of push constant per shader stage (fragment, vertex, etc).
+    uint8_t size;
+};
 
-    GLuint const id = glCreateShader(GL_VERTEX_SHADER);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
+struct PipelineLayoutKey {
+    using DescriptorSetLayoutArray = std::array<VkDescriptorSetLayout, UNIQUE_DESCRIPTOR_SET_COUNT>;
+    DescriptorSetLayoutArray descSetLayouts = {};        // 8 * 3
+    PushConstantKey pushConstant[SHADER_TYPE_COUNT] = {};// 2 * 3
+    uint16_t padding = 0;
+};
+static_assert(sizeof(PipelineLayoutKey) == 32);
 
-    glShaderSource(id, 1, &src, &len);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
+using PipelineLayoutKeyHashFn = utils::hash::MurmurHashFn<PipelineLayoutKey>;
+struct PipelineLayoutKeyEqual {
+    bool operator()(PipelineLayoutKey const& k1, PipelineLayoutKey const& k2) const {
+        return 0 == memcmp((const void*) &k1, (const void*) &k2, sizeof(PipelineLayoutKey));
+    }
+};
 
-    glCompileShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
+struct PipelineLayoutCacheEntry {
+    VkPipelineLayout handle;
+    Timestamp lastUsed;
+};
 
-    GLint result = 0;
-    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
-    EXPECT_EQ(result, GL_TRUE);
+using PipelineLayoutMap = tsl::robin_map<PipelineLayoutKey, PipelineLayoutCacheEntry,
+        PipelineLayoutKeyHashFn, PipelineLayoutKeyEqual>;
 
-    glDeleteShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
+class TestClass {
+public:
+    VkDevice mDevice;
+    VulkanResourceAllocator* mAllocator;
+    Timestamp mTimestamp;
+    PipelineLayoutMap layout;
+};
+
+void insert(PipelineLayoutMap& layout, uint64_t val) {
+    PipelineLayoutKey key{};
+    key.descSetLayouts[0] = (VkDescriptorSetLayout) val;
+    layout[key] = {(VkPipelineLayout) val, val};
 }
 
-TEST_F(CompilerTest, CrashPVRUniFlexCompileToHw) {
-
-    // Some PowerVR driver crash with this shader
-
-    auto shader = R"(
-#version 300 es
-
-layout(location = 0) in vec4 mesh_position;
-
-layout(std140) uniform FrameUniforms {
-    vec2 i;
-} frameUniforms;
-
-void main() {
-    gl_Position = mesh_position;
-    gl_Position.z = dot(gl_Position.zw, frameUniforms.i);
-})"sv;
-
-    const char* const src = shader.data();
-    GLint const len = (GLint)shader.size();
-
-    GLuint const id = glCreateShader(GL_VERTEX_SHADER);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    glShaderSource(id, 1, &src, &len);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    glCompileShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    GLint result = 0;
-    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
-    EXPECT_EQ(result, GL_TRUE);
-
-    glDeleteShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-}
-
-TEST_F(CompilerTest, ConstParameters) {
-
-    // Some PowerVR driver fail to compile this shader
-
-    auto shader = R"(
-#version 300 es
-
-highp mat3 m;
-void buggy(const mediump vec3 n) {
-    m*n;
-}
-
-void main() {
-})"sv;
-
-    const char* const src = shader.data();
-    GLint const len = (GLint)shader.size();
-
-    GLuint const id = glCreateShader(GL_FRAGMENT_SHADER);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    glShaderSource(id, 1, &src, &len);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    glCompileShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    GLint result = 0;
-    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
-    EXPECT_EQ(result, GL_TRUE);
-
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-
-    glDeleteShader(id);
-    EXPECT_EQ(glGetError(), GL_NO_ERROR);
-}
+}// namespace
 
 int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
+    constexpr uint32_t START = 1000;
+    TestClass c;
+    auto& layout = c.layout;
+
+    uint64_t count = 0;
+    for (; count < 20; count++) {
+        insert(layout, count + START);
+    }
+
+    for (uint64_t t = 0; t < count; ++t) {
+        PipelineLayoutKey key = {};
+        key.descSetLayouts[0] = (VkDescriptorSetLayout)(START + t);
+
+        if (layout.find(key) != layout.end()) {
+            std::cout << "found " << t << std::endl;
+        } else {
+            std::cout << "not found" << t << std::endl;
+        }
+    }
+
+    return 0;
 }

filament/test/filament_framegraph_test.cpp

@@ -34,6 +34,10 @@ using namespace backend;
 
 class MockResourceAllocator : public ResourceAllocatorInterface {
     uint32_t handle = 0;
+    struct MockDisposer : public ResourceAllocatorDisposerInterface {
+        void destroy(backend::TextureHandle) noexcept override {}
+    } disposer;
+
 public:
     backend::RenderTargetHandle createRenderTarget(const char* name,
             backend::TargetBufferFlags targetBufferFlags,
@@ -60,6 +64,10 @@ public:
 
     void destroyTexture(backend::TextureHandle h) noexcept override {
     }
+
+    ResourceAllocatorDisposerInterface& getDisposer() noexcept override {
+        return disposer;
+    }
 };
 
 class FrameGraphTest : public testing::Test {

libs/gltfio/src/AssetLoader.cpp

@@ -58,6 +58,8 @@
 
 #include "downcast.h"
 
+#include <codecvt>
+#include <locale>
 #include <memory>
 
 using namespace filament;
@@ -88,12 +90,57 @@ static constexpr cgltf_material kDefaultMat = {
     },
 };
 
-static const char* getNodeName(const cgltf_node* node, const char* defaultNodeName) {
-    if (node->name) return node->name;
-    if (node->mesh && node->mesh->name) return node->mesh->name;
-    if (node->light && node->light->name) return node->light->name;
-    if (node->camera && node->camera->name) return node->camera->name;
-    return defaultNodeName;
+static std::string getNodeName(cgltf_node const* node, char const* defaultNodeName) {
+    auto const getNameImpl = [node, defaultNodeName]() -> char const* {
+        if (node->name) return node->name;
+        if (node->mesh && node->mesh->name) return node->mesh->name;
+        if (node->light && node->light->name) return node->light->name;
+        if (node->camera && node->camera->name) return node->camera->name;
+        return defaultNodeName;
+    };
+
+    std::string strOrig(getNameImpl());
+
+    // We handle the potential case of escaped characters in the JSON which should be properly
+    // interpreted as unicode. See spec:
+    // https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#json-encoding
+    // Also see spec for escaped strings in JSON (Section 2.5) https://www.ietf.org/rfc/rfc4627.txt
+
+    std::string strEscaped;
+    size_t cur = 0, idx = 0;
+    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
+
+    auto const addUnencodedSubstr = [&](size_t cursor, size_t nextPoint) {
+        assert_invariant(nextPoint >= cursor);
+        if (cursor == nextPoint) {
+            return;
+        }
+        strEscaped += strOrig.substr(cursor, nextPoint - cursor);
+    };
+
+    while ((idx = strOrig.find("\\u", cur)) != std::string::npos) {
+        if (idx + 6 > strOrig.length()) {
+            utils::slog.w << "gltfio: Unable to interpret node name=" << strOrig
+                          << " as proper unicode encoding." << utils::io::endl;
+            return strOrig;
+        }
+
+        // Turns string of the form \u0062 to 0x0062
+        std::string const hexStr = strOrig.substr(idx + 2, 4);
+        if (hexStr.find_first_not_of("0123456789abcdefABCDEF") != std::string::npos) {
+            utils::slog.w << "gltfio: Unable to interpret node name=" << strOrig
+                          << " as proper unicode encoding." << utils::io::endl;
+            return strOrig;
+        }
+
+        addUnencodedSubstr(cur, idx);
+
+        strEscaped += conv.to_bytes((char32_t) std::stoul(hexStr, nullptr, 16));
+        cur = idx + 6;
+    }
+    addUnencodedSubstr(cur, strOrig.length());
+
+    return strEscaped;
 }
 
 static bool primitiveHasVertexColor(const cgltf_primitive& inPrim) {
@@ -504,7 +551,8 @@ FFilamentAsset* FAssetLoader::createRootAsset(const cgltf_data* srcAsset) {
 }
 
 void FAssetLoader::recursePrimitives(const cgltf_node* node, FFilamentAsset* fAsset) {
-    const char* name = getNodeName(node, mDefaultNodeName);
+    auto nameStr = getNodeName(node, mDefaultNodeName);
+    const char* name = nameStr.c_str();
     name = name ? name : "node";
 
     if (node->mesh) {
@@ -573,7 +621,8 @@ void FAssetLoader::recurseEntities(const cgltf_node* node, SceneMask scenes, Ent
     instance->mEntities.push_back(entity);
     instance->mNodeMap[node - srcAsset->nodes] = entity;
 
-    const char* name = getNodeName(node, mDefaultNodeName);
+    auto nameStr = getNodeName(node, mDefaultNodeName);
+    const char* name = nameStr.c_str();
 
     if (name) {
         fAsset->mNameToEntity[name].push_back(entity);

third_party/unordered_dense/.gitignore

@@ -1,14 +0,0 @@
-build
-builddir
-.cache
-.vscode
-compile_commands.json
-
-# ignore all in subprojects except the .wrap files
-/subprojects/*
-!/subprojects/*.wrap
-
-# c++ modules
-*.pcm
-a.out
-*.o

third_party/unordered_dense/CMakeLists.txt

@@ -1,61 +0,0 @@
-cmake_minimum_required(VERSION 3.12)
-project("unordered_dense"
-    VERSION 4.4.0
-    DESCRIPTION "A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion"
-    HOMEPAGE_URL "https://github.com/martinus/unordered_dense")
-
-include(GNUInstallDirs)
-
-# determine whether this is a standalone project or included by other projects
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-    set(_unordered_dense_is_toplevel_project TRUE)
-else()
-    set(_unordered_dense_is_toplevel_project FALSE)
-endif()
-
-add_library(unordered_dense INTERFACE)
-add_library(unordered_dense::unordered_dense ALIAS unordered_dense)
-
-target_include_directories(
-    unordered_dense
-    INTERFACE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-
-target_compile_features(unordered_dense INTERFACE cxx_std_17)
-
-if(_unordered_dense_is_toplevel_project)
-    # locations are provided by GNUInstallDirs
-    install(
-        TARGETS unordered_dense
-        EXPORT unordered_dense_Targets
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-    include(CMakePackageConfigHelpers)
-    write_basic_package_version_file(
-        "unordered_denseConfigVersion.cmake"
-        VERSION ${PROJECT_VERSION}
-        COMPATIBILITY SameMajorVersion)
-
-    configure_package_config_file(
-        "${PROJECT_SOURCE_DIR}/cmake/unordered_denseConfig.cmake.in"
-        "${PROJECT_BINARY_DIR}/unordered_denseConfig.cmake"
-        INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-
-    install(
-        EXPORT unordered_dense_Targets
-        FILE unordered_denseTargets.cmake
-        NAMESPACE unordered_dense::
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-
-    install(
-        FILES "${PROJECT_BINARY_DIR}/unordered_denseConfig.cmake"
-        "${PROJECT_BINARY_DIR}/unordered_denseConfigVersion.cmake"
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
-
-    install(
-        DIRECTORY ${PROJECT_SOURCE_DIR}/include/ankerl
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-endif()

third_party/unordered_dense/CODE_OF_CONDUCT.md

@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at martin.ankerl@gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

third_party/unordered_dense/CONTRIBUTING.md

@@ -1,3 +0,0 @@
-* Coding style should be consistent with the code around you.
-* Use automatic formatting with clang-format.
-* One feature per pull request

third_party/unordered_dense/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Martin Leitner-Ankerl
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

third_party/unordered_dense/README.md

@@ -1,374 +0,0 @@
-<a id="top"></a>
-
-[![Release](https://img.shields.io/github/release/martinus/unordered_dense.svg)](https://github.com/martinus/unordered_dense/releases)
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/martinus/unordered_dense/main/LICENSE)
-[![meson_build_test](https://github.com/martinus/unordered_dense/actions/workflows/main.yml/badge.svg)](https://github.com/martinus/unordered_dense/actions)
-[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/6220/badge)](https://bestpractices.coreinfrastructure.org/projects/6220)
-[![Sponsors](https://img.shields.io/github/sponsors/martinus?style=social)](https://github.com/sponsors/martinus)
-
-# 🚀 ankerl::unordered_dense::{map, set} <!-- omit in toc -->
-
-A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion for C++17 and later.
-
-The classes `ankerl::unordered_dense::map` and `ankerl::unordered_dense::set` are (almost) drop-in replacements of `std::unordered_map` and `std::unordered_set`. While they don't have as strong iterator / reference stability guaranties, they are typically *much* faster.
-
-Additionally, there are `ankerl::unordered_dense::segmented_map` and `ankerl::unordered_dense::segmented_set` with lower peak memory usage. and stable iterator/references on insert.
-
-- [1. Overview](#1-overview)
-- [2. Installation](#2-installation)
-  - [2.1. Installing using cmake](#21-installing-using-cmake)
-- [3. Usage](#3-usage)
-  - [3.1. Modules](#31-modules)
-  - [3.2. Hash](#32-hash)
-    - [3.2.1. Simple Hash](#321-simple-hash)
-    - [3.2.2. High Quality Hash](#322-high-quality-hash)
-    - [3.2.3. Specialize `ankerl::unordered_dense::hash`](#323-specialize-ankerlunordered_densehash)
-    - [3.2.4. Heterogeneous Overloads using `is_transparent`](#324-heterogeneous-overloads-using-is_transparent)
-    - [3.2.5. Automatic Fallback to `std::hash`](#325-automatic-fallback-to-stdhash)
-    - [3.2.6. Hash the Whole Memory](#326-hash-the-whole-memory)
-  - [3.3. Container API](#33-container-api)
-    - [3.3.1. `auto extract() && -> value_container_type`](#331-auto-extract----value_container_type)
-    - [3.3.2. `extract()` single Elements](#332-extract-single-elements)
-    - [3.3.3. `[[nodiscard]] auto values() const noexcept -> value_container_type const&`](#333-nodiscard-auto-values-const-noexcept---value_container_type-const)
-    - [3.3.4. `auto replace(value_container_type&& container)`](#334-auto-replacevalue_container_type-container)
-  - [3.4. Custom Container Types](#34-custom-container-types)
-  - [3.5. Custom Bucket Types](#35-custom-bucket-types)
-    - [3.5.1. `ankerl::unordered_dense::bucket_type::standard`](#351-ankerlunordered_densebucket_typestandard)
-    - [3.5.2. `ankerl::unordered_dense::bucket_type::big`](#352-ankerlunordered_densebucket_typebig)
-- [4. `segmented_map` and `segmented_set`](#4-segmented_map-and-segmented_set)
-- [5. Design](#5-design)
-  - [5.1. Inserts](#51-inserts)
-  - [5.2. Lookups](#52-lookups)
-  - [5.3. Removals](#53-removals)
-- [6. Real World Usage](#6-real-world-usage)
-
-## 1. Overview
-
-The chosen design has a few advantages over `std::unordered_map`: 
-
-* Perfect iteration speed - Data is stored in a `std::vector`, all data is contiguous!
-* Very fast insertion & lookup speed, in the same ballpark as [`absl::flat_hash_map`](https://abseil.io/docs/cpp/guides/container`)
-* Low memory usage
-* Full support for `std::allocators`, and [polymorphic allocators](https://en.cppreference.com/w/cpp/memory/polymorphic_allocator). There are `ankerl::unordered_dense::pmr` typedefs available
-* Customizeable storage type: with a template parameter you can e.g. switch from `std::vector` to `boost::interprocess::vector` or any other compatible random-access container.
-* Better debugging: the underlying data can be easily seen in any debugger that can show an `std::vector`.
-
-There's no free lunch, so there are a few disadvantages:
-
-* Deletion speed is relatively slow. This needs two lookups: one for the element to delete, and one for the element that is moved onto the newly empty spot.
-* no `const Key` in `std::pair<Key, Value>`
-* Iterators and references are not stable on insert or erase.
-
-## 2. Installation
-
-<!-- See https://github.com/bernedom/SI/blob/main/doc/installation-guide.md -->
-The default installation location is `/usr/local`.
-
-### 2.1. Installing using cmake 
-
-Clone the repository and run these commands in the cloned folder:
-
-```sh
-mkdir build && cd build
-cmake ..
-cmake --build . --target install
-```
-
-Consider setting an install prefix if you do not want to install `unordered_dense` system wide, like so:
-
-```sh
-mkdir build && cd build
-cmake -DCMAKE_INSTALL_PREFIX:PATH=${HOME}/unordered_dense_install ..
-cmake --build . --target install
-```
-
-To make use of the installed library, add this to your project:
-
-```cmake
-find_package(unordered_dense CONFIG REQUIRED)
-target_link_libraries(your_project_name unordered_dense::unordered_dense)
-```
-
-## 3. Usage
-
-### 3.1. Modules
-
-`ankerl::unordered_dense` supports c++20 modules. Simply compile `src/ankerl.unordered_dense.cpp` and use the resulting module, e.g. like so:
-
-```sh
-clang++ -std=c++20 -I include --precompile -x c++-module src/ankerl.unordered_dense.cpp
-clang++ -std=c++20 -c ankerl.unordered_dense.pcm
-```
-
-To use the module with e.g. in `module_test.cpp`, use 
-
-```cpp
-import ankerl.unordered_dense;
-```
-
-and compile with e.g.
-
-```sh
-clang++ -std=c++20 -fprebuilt-module-path=. ankerl.unordered_dense.o module_test.cpp -o main
-```
-
-A simple demo script can be found in `test/modules`.
-
-### 3.2. Hash
-
-`ankerl::unordered_dense::hash` is a fast and high quality hash, based on [wyhash](https://github.com/wangyi-fudan/wyhash). The `ankerl::unordered_dense` map/set differentiates between hashes of high quality (good [avalanching effect](https://en.wikipedia.org/wiki/Avalanche_effect)) and bad quality. Hashes with good quality contain a special marker:
-
-```cpp
-using is_avalanching = void;
-```
-
-This is the cases for the specializations `bool`, `char`, `signed char`, `unsigned char`, `char8_t`, `char16_t`, `char32_t`, `wchar_t`, `short`, `unsigned short`, `int`, `unsigned int`, `long`, `long long`, `unsigned long`, `unsigned long long`, `T*`, `std::unique_ptr<T>`, `std::shared_ptr<T>`, `enum`, `std::basic_string<C>`, and `std::basic_string_view<C>`.
-
-Hashes that do not contain such a marker are assumed to be of bad quality and receive an additional mixing step inside the map/set implementation.
-
-#### 3.2.1. Simple Hash
-
-Consider a simple custom key type:
-
-```cpp
-struct id {
-    uint64_t value{};
-
-    auto operator==(id const& other) const -> bool {
-        return value == other.value;
-    }
-};
-```
-
-The simplest implementation of a hash is this:
-
-```cpp
-struct custom_hash_simple {
-    auto operator()(id const& x) const noexcept -> uint64_t {
-        return x.value;
-    }
-};
-```
-This can be used e.g. with 
-
-```cpp
-auto ids = ankerl::unordered_dense::set<id, custom_hash_simple>();
-```
-
-Since `custom_hash_simple` doesn't have a `using is_avalanching = void;` marker it is considered to be of bad quality and additional mixing of `x.value` is automatically provided inside the set.
-
-#### 3.2.2. High Quality Hash
-
-Back to the `id` example, we can easily implement a higher quality hash:
-
-```cpp
-struct custom_hash_avalanching {
-    using is_avalanching = void;
-
-    auto operator()(id const& x) const noexcept -> uint64_t {
-        return ankerl::unordered_dense::detail::wyhash::hash(x.value);
-    }
-};
-```
-
-We know `wyhash::hash` is of high quality, so we can add `using is_avalanching = void;` which makes the map/set directly use the returned value.
-
-
-#### 3.2.3. Specialize `ankerl::unordered_dense::hash`
-
-Instead of creating a new class you can also specialize `ankerl::unordered_dense::hash`:
-
-```cpp
-template <>
-struct ankerl::unordered_dense::hash<id> {
-    using is_avalanching = void;
-
-    [[nodiscard]] auto operator()(id const& x) const noexcept -> uint64_t {
-        return detail::wyhash::hash(x.value);
-    }
-};
-```
-
-#### 3.2.4. Heterogeneous Overloads using `is_transparent`
-
-This map/set supports heterogeneous overloads as described in [P2363 Extending associative containers with the remaining heterogeneous overloads](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2363r3.html) which is [targeted for C++26](https://wg21.link/p2077r2). This has overloads for `find`, `count`, `contains`, `equal_range` (see [P0919R3](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0919r3.html)), `erase` (see [P2077R2](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2077r2.html)), and  `try_emplace`, `insert_or_assign`, `operator[]`, `at`, and `insert` & `emplace` for sets (see [P2363R3](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2363r3.html)).
-
-For heterogeneous overloads to take affect, both `hasher` and `key_equal` need to have the attribute `is_transparent` set.
-
-Here is an example implementation that's usable with any string types that is convertible to `std::string_view` (e.g. `char const*` and `std::string`):
-
-```cpp
-struct string_hash {
-    using is_transparent = void; // enable heterogeneous overloads
-    using is_avalanching = void; // mark class as high quality avalanching hash
-
-    [[nodiscard]] auto operator()(std::string_view str) const noexcept -> uint64_t {
-        return ankerl::unordered_dense::hash<std::string_view>{}(str);
-    }
-};
-```
-
-To make use of this hash you'll need to specify it as a type, and also a `key_equal` with `is_transparent` like [std::equal_to<>](https://en.cppreference.com/w/cpp/utility/functional/equal_to_void):
-
-```cpp
-auto map = ankerl::unordered_dense::map<std::string, size_t, string_hash, std::equal_to<>>();
-```
-
-For more information see the examples in `test/unit/transparent.cpp`.
-
-
-#### 3.2.5. Automatic Fallback to `std::hash`
-
-When an implementation for `std::hash` of a custom type is available, this is automatically used and assumed to be of bad quality (thus `std::hash` is used, but an additional mixing step is performed).
-
-
-#### 3.2.6. Hash the Whole Memory
-
-When the type [has a unique object representation](https://en.cppreference.com/w/cpp/types/has_unique_object_representations) (no padding, trivially copyable), one can just hash the object's memory. Consider a simple class
-
-```cpp
-struct point {
-    int x{};
-    int y{};
-
-    auto operator==(point const& other) const -> bool {
-        return x == other.x && y == other.y;
-    }
-};
-```
-
-A fast and high quality hash can be easily provided like so:
-
-```cpp
-struct custom_hash_unique_object_representation {
-    using is_avalanching = void;
-
-    [[nodiscard]] auto operator()(point const& f) const noexcept -> uint64_t {
-        static_assert(std::has_unique_object_representations_v<point>);
-        return ankerl::unordered_dense::detail::wyhash::hash(&f, sizeof(f));
-    }
-};
-```
-
-### 3.3. Container API
-
-In addition to the standard `std::unordered_map` API (see https://en.cppreference.com/w/cpp/container/unordered_map) we have additional API that is somewhat similar to the node API, but leverages the fact that we're using a random access container internally:
-
-#### 3.3.1. `auto extract() && -> value_container_type`
-
-Extracts the internally used container. `*this` is emptied.
-
-#### 3.3.2. `extract()` single Elements
-
-Similar to `erase()` I have an API call `extract()`. It behaves exactly the same as `erase`, except that the return value is the moved element that is removed from the container:
-
-* `auto extract(const_iterator it) -> value_type`
-* `auto extract(Key const& key) -> std::optional<value_type>`
-* `template <class K> auto extract(K&& key) -> std::optional<value_type>`
-
-Note that the `extract(key)` API returns an `std::optional<value_type>` that is empty when the key is not found.
-
-#### 3.3.3. `[[nodiscard]] auto values() const noexcept -> value_container_type const&`
-
-Exposes the underlying values container.
-
-#### 3.3.4. `auto replace(value_container_type&& container)`
-
-Discards the internally held container and replaces it with the one passed. Non-unique elements are
-removed, and the container will be partly reordered when non-unique elements are found.
-
-### 3.4. Custom Container Types
-
-`unordered_dense` accepts a custom allocator, but you can also specify a custom container for that template argument. That way it is possible to replace the internally used `std::vector` with e.g. `std::deque` or any other container like `boost::interprocess::vector`. This supports fancy pointers (e.g. [offset_ptr](https://www.boost.org/doc/libs/1_80_0/doc/html/interprocess/offset_ptr.html)), so the container can be used with e.g. shared memory provided by `boost::interprocess`.
-
-### 3.5. Custom Bucket Types
-
-The map/set supports two different bucket types. The default should be good for pretty much everyone.
-
-#### 3.5.1. `ankerl::unordered_dense::bucket_type::standard`
-
-* Up to 2^32 = 4.29 billion elements.
-* 8 bytes overhead per bucket.
-
-#### 3.5.2. `ankerl::unordered_dense::bucket_type::big`
-
-* up to 2^63 = 9223372036854775808 elements.
-* 12 bytes overhead per bucket.
-
-## 4. `segmented_map` and `segmented_set`
-
-`ankerl::unordered_dense` provides a custom container implementation that has lower memory requirements than the default `std::vector`. Memory is not contiguous, but it can allocate segments without having to reallocate and move all the elements. In summary, this leads to
-
-* Much smoother memory usage, memory usage increases continuously.
-* No high peak memory usage.
-* Faster insertion because elements never need to be moved to new allocated blocks
-* Slightly slower indexing compared to `std::vector` because an additional indirection is needed.
-
-Here is a comparison against `absl::flat_hash_map` and the `ankerl::unordered_dense::map` when inserting 10 million entries
-![allocated memory](doc/allocated_memory.png)
-
-Abseil is fastest for this simple inserting test, taking a bit over 0.8 seconds. It's peak memory usage is about 430 MB. Note how the memory usage goes down after the last peak; when it goes down to ~290MB it has finished rehashing and could free the previously used memory block.
-
-`ankerl::unordered_dense::segmented_map` doesn't have these peaks, and instead has a smooth increase of memory usage. Note there are still sudden drops & increases in memory because the indexing data structure needs still needs to increase by a fixed factor. But due to holding the data in a separate container we are able to first free the old data structure, and then allocate a new, bigger indexing structure; thus we do not have peaks.
-
-## 5. Design
-
-The map/set has two data structures:
-* `std::vector<value_type>` which holds all data. map/set iterators are just `std::vector<value_type>::iterator`!
-* An indexing structure (bucket array), which is a flat array with 8-byte buckets.
-
-### 5.1. Inserts
-
-Whenever an element is added it is `emplace_back` to the vector. The key is hashed, and an entry (bucket) is added at the
-corresponding location in the bucket array. The bucket has this structure:
-
-```cpp
-struct Bucket {
-    uint32_t dist_and_fingerprint;
-    uint32_t value_idx;
-};
-```
-
-Each bucket stores 3 things:
-* The distance of that value from the original hashed location (3 most significant bytes in `dist_and_fingerprint`)
-* A fingerprint; 1 byte of the hash (lowest significant byte in `dist_and_fingerprint`)
-* An index where in the vector the actual data is stored.
-
-This structure is especially designed for the collision resolution strategy robin-hood hashing with backward shift
-deletion.
-
-### 5.2. Lookups
-
-The key is hashed and the bucket array is searched if it has an entry at that location with that fingerprint. When found,
-the key in the data vector is compared, and when equal the value is returned.
-
-### 5.3. Removals
-
-Since all data is stored in a vector, removals are a bit more complicated:
-
-1. First, lookup the element to delete in the index array.
-2. When found, replace that element in the vector with the last element in the vector. 
-3. Update *two* locations in the bucket array: First remove the bucket for the removed element
-4. Then, update the `value_idx` of the moved element. This requires another lookup.
-
-
-## 6. Real World Usage
-
-On 2023-09-10 I did a quick search on github to see if this map is used in any popular open source projects. Here are some of the projects
-I found. Please send me a note if you want on that list!
-
-* [PruaSlicer](https://github.com/prusa3d/PrusaSlicer) -  G-code generator for 3D printers (RepRap, Makerbot, Ultimaker etc.) 
-* [Kismet](https://github.com/kismetwireless/kismet): Wi-Fi, Bluetooth, RF, and more. Kismet is a sniffer, WIDS, and wardriving tool for Wi-Fi, Bluetooth, Zigbee, RF, and more, which runs on Linux and macOS
-* [Rspamd](https://github.com/rspamd/rspamd) - Fast, free and open-source spam filtering system.
-* [kallisto](https://github.com/pachterlab/kallisto) -  Near-optimal RNA-Seq quantification
-* [Slang](https://github.com/shader-slang/slang) - Slang is a shading language that makes it easier to build and maintain large shader codebases in a modular and extensible fashion.
-* [CyberFSR2](https://github.com/PotatoOfDoom/CyberFSR2) - Drop-in DLSS replacement with FSR 2.0 for various games such as Cyberpunk 2077.
-* [ossia score](https://github.com/ossia/score) - A free, open-source, cross-platform intermedia sequencer for precise and flexible scripting of interactive scenarios. 
-* [HiveWE](https://github.com/stijnherfst/HiveWE) - A Warcraft III World Editor (WE) that focusses on speed and ease of use.
-* [opentxs](https://github.com/Open-Transactions/opentxs) - The Open-Transactions project is a collaborative effort to develop a robust, commercial-grade, fully-featured, free-software toolkit implementing the OTX protocol as well as a full-strength financial cryptography library, API, GUI, command-line interface, and prototype notary server.
-* [LuisaCompute](https://github.com/LuisaGroup/LuisaCompute) - High-Performance Rendering Framework on Stream Architectures
-* [Lethe](https://github.com/lethe-cfd/lethe) - Lethe (pronounced /ˈliːθiː/) is open-source computational fluid dynamics (CFD) software which uses high-order continuous Galerkin formulations to solve the incompressible Navier–Stokes equations (among others).
-* [PECOS](https://github.com/amzn/pecos) - PECOS is a versatile and modular machine learning (ML) framework for fast learning and inference on problems with large output spaces, such as extreme multi-label ranking (XMR) and large-scale retrieval.
-* [Operon](https://github.com/heal-research/operon) - A modern C++ framework for symbolic regression that uses genetic programming to explore a hypothesis space of possible mathematical expressions in order to find the best-fitting model for a given regression target.
-* [MashMap](https://github.com/marbl/MashMap) - A fast approximate aligner for long DNA sequences
-* [minigpt4.cpp](https://github.com/Maknee/minigpt4.cpp) - Port of MiniGPT4 in C++ (4bit, 5bit, 6bit, 8bit, 16bit CPU inference with GGML)

third_party/unordered_dense/cmake/unordered_denseConfig.cmake.in

@@ -1,4 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
-check_required_components("@PROJECT_NAME@")

third_party/unordered_dense/data/fuzz/fuzz_api/00b120066609a5d8f34a0faab4008a1a.00000010.honggfuzz.cov

@@ -1 +0,0 @@
-§ount-aftpuu=o=d

third_party/unordered_dense/data/fuzz/fuzz_api/00d4e4e4e4e4e4774c54e4e4e4e4e4e4.00000010.honggfuzz.cov

@@ -1 +0,0 @@
-=<3D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

third_party/unordered_dense/data/fuzz/fuzz_api/02a00000e38104353fe0716870000000.00000010.honggfuzz.cov

@@ -1 +0,0 @@
-nU
€UUUUUUUUUUUU

third_party/unordered_dense/data/fuzz/fuzz_api/02b1224a7a165d6f0642336bb63347dc.00000020.honggfuzz.cov

@@ -1 +0,0 @@
-dt-q=fu{
€W<$
=×test-case=nX¶)u

third_party/unordered_dense/data/fuzz/fuzz_api/059102b7b7648f18da3c744c7b7c1253.00000020.honggfuzz.cov

@@ -1 +0,0 @@
-dt-nddt-qàÿÿÿÿÿÿno-line-number

third_party/unordered_dense/data/fuzz/fuzz_api/060d4caf04d0e6b409d104c643a025ba.00000020.honggfuzz.cov

@@ -1 +0,0 @@
-ødt-exitnlist-reporterso-tkipped

third_party/unordered_dense/data/fuzz/fuzz_api/06d2184ff06fa75dd490c7ac07bee262.0000002e.honggfuzz.cov

@@ -1 +0,0 @@
-dt-exnÿÿÿÿÿÿàno-exitcode=path-filenamesitlr"

third_party/unordered_dense/data/fuzz/fuzz_api/07b5f62901ef073dbc9220e69a4b1dab.00000040.honggfuzz.cov

@@ -1 +0,0 @@
-å?fordt-ablisssssssssssssssssssssst-reportergfl=ors=-cas-caseeee

third_party/unordered_dense/data/fuzz/fuzz_api/07f839f695a0d6f7df49f5f91abbe3e2.00000020.honggfuzz.cov

@@ -1 +0,0 @@
-dt-ndt-tce=Ăcou~˙˙˙˙nt˙řncfctĂ

third_party/unordered_dense/data/fuzz/fuzz_api/086393821cb79cf5033c87fca2639382.00000008.honggfuzz.cov

@@ -1 +0,0 @@
-"dt-nssn