Merge branch 'navmesh_cache_simplification' into 'master'

Simplify navmesh cache

See merge request OpenMW/openmw!691

CMakeLists.txt

@@ -34,6 +34,7 @@ option(BUILD_NIFTEST            "Build nif file tester" ON)
 option(BUILD_DOCS               "Build documentation." OFF )
 option(BUILD_WITH_CODE_COVERAGE "Enable code coverage with gconv" OFF)
 option(BUILD_UNITTESTS          "Enable Unittests with Google C++ Unittest" OFF)
+option(BUILD_BENCHMARKS         "Build benchmarks with Google Benchmark" OFF)
 option(BULLET_USE_DOUBLES       "Use double precision for Bullet" ON)
 
 set(OpenGL_GL_PREFERENCE LEGACY)  # Use LEGACY as we use GL2; GLNVD is for GL3 and up.
@@ -549,6 +550,10 @@ if (BUILD_UNITTESTS)
   add_subdirectory( apps/openmw_test_suite )
 endif()
 
+if (BUILD_BENCHMARKS)
+  add_subdirectory(apps/benchmarks)
+endif()
+
 if (WIN32)
   if (MSVC)
     if (OPENMW_MP_BUILD)

apps/benchmarks/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.11)
+
+set(BENCHMARK_ENABLE_TESTING OFF)
+set(BENCHMARK_ENABLE_INSTALL OFF)
+set(BENCHMARK_ENABLE_GTEST_TESTS OFF)
+
+set(SAVED_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+string(REPLACE "-Wsuggest-override" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+string(REPLACE "-Wundef" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+include(FetchContent)
+FetchContent_Declare(benchmark
+    URL https://github.com/google/benchmark/archive/refs/tags/v1.5.2.zip
+    URL_HASH MD5=49395b757a7c4656d70f1328d93efd00
+    SOURCE_DIR fetched/benchmark
+)
+FetchContent_MakeAvailableExcludeFromAll(benchmark)
+
+set(CMAKE_CXX_FLAGS "${SAVED_CMAKE_CXX_FLAGS}")
+
+openmw_add_executable(openmw_detournavigator_navmeshtilescache_benchmark detournavigator/navmeshtilescache.cpp)
+target_compile_options(openmw_detournavigator_navmeshtilescache_benchmark PRIVATE -Wall)
+target_compile_features(openmw_detournavigator_navmeshtilescache_benchmark PRIVATE cxx_std_17)
+target_link_libraries(openmw_detournavigator_navmeshtilescache_benchmark benchmark::benchmark components)
+
+if (UNIX AND NOT APPLE)
+    target_link_libraries(openmw_detournavigator_navmeshtilescache_benchmark ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+if (MSVC)
+    if (CMAKE_CL_64)
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /bigobj")
+    endif (CMAKE_CL_64)
+endif (MSVC)

apps/benchmarks/detournavigator/navmeshtilescache.cpp

@@ -0,0 +1,215 @@
+#include <benchmark/benchmark.h>
+
+#include <components/detournavigator/navmeshtilescache.hpp>
+
+#include <algorithm>
+#include <random>
+#include <iostream>
+
+namespace
+{
+    using namespace DetourNavigator;
+
+    struct Key
+    {
+        osg::Vec3f mAgentHalfExtents;
+        TilePosition mTilePosition;
+        RecastMesh mRecastMesh;
+        std::vector<OffMeshConnection> mOffMeshConnections;
+    };
+
+    struct Item
+    {
+        Key mKey;
+        NavMeshData mValue;
+    };
+
+    template <typename Random>
+    TilePosition generateTilePosition(int max, Random& random)
+    {
+        std::uniform_int_distribution<int> distribution(0, max);
+        return TilePosition(distribution(random), distribution(random));
+    }
+
+    template <typename Random>
+    osg::Vec3f generateAgentHalfExtents(float min, float max, Random& random)
+    {
+        std::uniform_int_distribution<int> distribution(min, max);
+        return osg::Vec3f(distribution(random), distribution(random), distribution(random));
+    }
+
+    template <typename OutputIterator, typename Random>
+    void generateVertices(OutputIterator out, std::size_t number, Random& random)
+    {
+        std::uniform_real_distribution<float> distribution(0.0, 1.0);
+        std::generate_n(out, 3 * (number - number % 3), [&] { return distribution(random); });
+    }
+
+    template <typename OutputIterator, typename Random>
+    void generateIndices(OutputIterator out, int max, std::size_t number, Random& random)
+    {
+        std::uniform_int_distribution<int> distribution(0, max);
+        std::generate_n(out, number - number % 3, [&] { return distribution(random); });
+    }
+
+    AreaType toAreaType(int index)
+    {
+        switch (index)
+        {
+            case 0: return AreaType_null;
+            case 1: return AreaType_water;
+            case 2: return AreaType_door;
+            case 3: return AreaType_pathgrid;
+            case 4: return AreaType_ground;
+        }
+        return AreaType_null;
+    }
+
+    template <typename Random>
+    AreaType generateAreaType(Random& random)
+    {
+        std::uniform_int_distribution<int> distribution(0, 4);
+        return toAreaType(distribution(random));;
+    }
+
+    template <typename OutputIterator, typename Random>
+    void generateAreaTypes(OutputIterator out, std::size_t triangles, Random& random)
+    {
+        std::generate_n(out, triangles, [&] { return generateAreaType(random); });
+    }
+
+    template <typename OutputIterator, typename Random>
+    void generateWater(OutputIterator out, std::size_t count, Random& random)
+    {
+        std::uniform_real_distribution<btScalar> distribution(0.0, 1.0);
+        std::generate_n(out, count, [&] {
+            const btVector3 shift(distribution(random), distribution(random), distribution(random));
+            return RecastMesh::Water {1, btTransform(btMatrix3x3::getIdentity(), shift)};
+        });
+    }
+
+    template <typename OutputIterator, typename Random>
+    void generateOffMeshConnection(OutputIterator out, std::size_t count, Random& random)
+    {
+        std::uniform_real_distribution<btScalar> distribution(0.0, 1.0);
+        std::generate_n(out, count, [&] {
+            const osg::Vec3f start(distribution(random), distribution(random), distribution(random));
+            const osg::Vec3f end(distribution(random), distribution(random), distribution(random));
+            return OffMeshConnection {start, end, generateAreaType(random)};
+        });
+    }
+
+    template <class Random>
+    Key generateKey(std::size_t triangles, Random& random)
+    {
+        const osg::Vec3f agentHalfExtents = generateAgentHalfExtents(0.5, 1.5, random);
+        const TilePosition tilePosition = generateTilePosition(10000, random);
+        const std::size_t generation = std::uniform_int_distribution<std::size_t>(0, 100)(random);
+        const std::size_t revision = std::uniform_int_distribution<std::size_t>(0, 10000)(random);
+        std::vector<float> vertices;
+        generateVertices(std::back_inserter(vertices), triangles * 1.98, random);
+        std::vector<int> indices;
+        generateIndices(std::back_inserter(indices), static_cast<int>(vertices.size() / 3) - 1, vertices.size() * 1.53, random);
+        std::vector<AreaType> areaTypes;
+        generateAreaTypes(std::back_inserter(areaTypes), indices.size() / 3, random);
+        std::vector<RecastMesh::Water> water;
+        generateWater(std::back_inserter(water), 2, random);
+        const std::size_t trianglesPerChunk = 256;
+        RecastMesh recastMesh(generation, revision, std::move(indices), std::move(vertices),
+                              std::move(areaTypes), std::move(water), trianglesPerChunk);
+        std::vector<OffMeshConnection> offMeshConnections;
+        generateOffMeshConnection(std::back_inserter(offMeshConnections), 300, random);
+        return Key {agentHalfExtents, tilePosition, std::move(recastMesh), std::move(offMeshConnections)};
+    }
+
+    constexpr std::size_t trianglesPerTile = 310;
+
+    template <typename OutputIterator, typename Random>
+    void generateKeys(OutputIterator out, std::size_t count, Random& random)
+    {
+        std::generate_n(out, count, [&] { return generateKey(trianglesPerTile, random); });
+    }
+
+    template <typename OutputIterator, typename Random>
+    void fillCache(OutputIterator out, Random& random, NavMeshTilesCache& cache)
+    {
+        std::size_t size = cache.getStats().mNavMeshCacheSize;
+
+        while (true)
+        {
+            Key key = generateKey(trianglesPerTile, random);
+            cache.set(key.mAgentHalfExtents, key.mTilePosition, key.mRecastMesh, key.mOffMeshConnections, NavMeshData());
+            *out++ = std::move(key);
+            const std::size_t newSize = cache.getStats().mNavMeshCacheSize;
+            if (size >= newSize)
+                break;
+            size = newSize;
+        }
+    }
+
+    template <std::size_t maxCacheSize, int hitPercentage>
+    void getFromFilledCache(benchmark::State& state)
+    {
+        NavMeshTilesCache cache(maxCacheSize);
+        std::minstd_rand random;
+        std::vector<Key> keys;
+        fillCache(std::back_inserter(keys), random, cache);
+        generateKeys(std::back_inserter(keys), keys.size() * (100 - hitPercentage) / 100, random);
+        std::size_t n = 0;
+
+        while (state.KeepRunning())
+        {
+            const auto& key = keys[n++ % keys.size()];
+            const auto result = cache.get(key.mAgentHalfExtents, key.mTilePosition, key.mRecastMesh, key.mOffMeshConnections);
+            benchmark::DoNotOptimize(result);
+        }
+    }
+
+    constexpr auto getFromFilledCache_1m_100hit = getFromFilledCache<1 * 1024 * 1024, 100>;
+    constexpr auto getFromFilledCache_4m_100hit = getFromFilledCache<4 * 1024 * 1024, 100>;
+    constexpr auto getFromFilledCache_16m_100hit = getFromFilledCache<16 * 1024 * 1024, 100>;
+    constexpr auto getFromFilledCache_64m_100hit = getFromFilledCache<64 * 1024 * 1024, 100>;
+    constexpr auto getFromFilledCache_1m_70hit = getFromFilledCache<1 * 1024 * 1024, 70>;
+    constexpr auto getFromFilledCache_4m_70hit = getFromFilledCache<4 * 1024 * 1024, 70>;
+    constexpr auto getFromFilledCache_16m_70hit = getFromFilledCache<16 * 1024 * 1024, 70>;
+    constexpr auto getFromFilledCache_64m_70hit = getFromFilledCache<64 * 1024 * 1024, 70>;
+
+    template <std::size_t maxCacheSize>
+    void setToBoundedNonEmptyCache(benchmark::State& state)
+    {
+        NavMeshTilesCache cache(maxCacheSize);
+        std::minstd_rand random;
+        std::vector<Key> keys;
+        fillCache(std::back_inserter(keys), random, cache);
+        generateKeys(std::back_inserter(keys), keys.size() * 2, random);
+        std::reverse(keys.begin(), keys.end());
+        std::size_t n = 0;
+
+        while (state.KeepRunning())
+        {
+            const auto& key = keys[n++ % keys.size()];
+            const auto result = cache.set(key.mAgentHalfExtents, key.mTilePosition, key.mRecastMesh, key.mOffMeshConnections, NavMeshData());
+            benchmark::DoNotOptimize(result);
+        }
+    }
+
+    constexpr auto setToBoundedNonEmptyCache_1m = setToBoundedNonEmptyCache<1 * 1024 * 1024>;
+    constexpr auto setToBoundedNonEmptyCache_4m = setToBoundedNonEmptyCache<4 * 1024 * 1024>;
+    constexpr auto setToBoundedNonEmptyCache_16m = setToBoundedNonEmptyCache<16 * 1024 * 1024>;
+    constexpr auto setToBoundedNonEmptyCache_64m = setToBoundedNonEmptyCache<64 * 1024 * 1024>;
+} // namespace
+
+BENCHMARK(getFromFilledCache_1m_100hit);
+BENCHMARK(getFromFilledCache_4m_100hit);
+BENCHMARK(getFromFilledCache_16m_100hit);
+BENCHMARK(getFromFilledCache_64m_100hit);
+BENCHMARK(getFromFilledCache_1m_70hit);
+BENCHMARK(getFromFilledCache_4m_70hit);
+BENCHMARK(getFromFilledCache_16m_70hit);
+BENCHMARK(getFromFilledCache_64m_70hit);
+BENCHMARK(setToBoundedNonEmptyCache_1m);
+BENCHMARK(setToBoundedNonEmptyCache_4m);
+BENCHMARK(setToBoundedNonEmptyCache_16m);
+BENCHMARK(setToBoundedNonEmptyCache_64m);
+
+BENCHMARK_MAIN();

apps/openmw_test_suite/detournavigator/navmeshtilescache.cpp

@@ -77,7 +77,7 @@ namespace
         EXPECT_EQ(result.get(), (NavMeshDataRef {mData, 1}));
     }
 
-    TEST_F(DetourNavigatorNavMeshTilesCacheTest, set_existing_element_should_throw_exception)
+    TEST_F(DetourNavigatorNavMeshTilesCacheTest, set_existing_element_should_return_cached_element)
     {
         const std::size_t navMeshDataSize = 1;
         const std::size_t navMeshKeySize = cRecastMeshKeySize;
@@ -87,10 +87,9 @@ namespace
         NavMeshData anotherNavMeshData {anotherData, 1};
 
         cache.set(mAgentHalfExtents, mTilePosition, mRecastMesh, mOffMeshConnections, std::move(mNavMeshData));
-        EXPECT_THROW(
-            cache.set(mAgentHalfExtents, mTilePosition, mRecastMesh, mOffMeshConnections, std::move(anotherNavMeshData)),
-            InvalidArgument
-        );
+        const auto result = cache.set(mAgentHalfExtents, mTilePosition, mRecastMesh, mOffMeshConnections, std::move(anotherNavMeshData));
+        ASSERT_TRUE(result);
+        EXPECT_EQ(result.get(), (NavMeshDataRef {mData, 1}));
     }
 
     TEST_F(DetourNavigatorNavMeshTilesCacheTest, get_should_return_cached_value)

components/detournavigator/chunkytrimesh.hpp

@@ -46,6 +46,9 @@ namespace DetourNavigator
         ChunkyTriMesh(const std::vector<float>& verts, const std::vector<int>& tris,
                       const std::vector<AreaType>& flags, const std::size_t trisPerChunk);
 
+        ChunkyTriMesh(ChunkyTriMesh&&) = default;
+        ChunkyTriMesh& operator=(ChunkyTriMesh&&) = default;
+
         ChunkyTriMesh(const ChunkyTriMesh&) = delete;
         ChunkyTriMesh& operator=(const ChunkyTriMesh&) = delete;
 

components/detournavigator/makenavmesh.cpp

@@ -576,17 +576,8 @@ namespace DetourNavigator
                 return navMeshCacheItem->lock()->removeTile(changedTile);
             }
 
-            try
-            {
-                cachedNavMeshData = navMeshTilesCache.set(agentHalfExtents, changedTile, *recastMesh,
-                                                          offMeshConnections, std::move(navMeshData));
-            }
-            catch (const InvalidArgument&)
-            {
-                cachedNavMeshData = navMeshTilesCache.get(agentHalfExtents, changedTile, *recastMesh,
-                                                          offMeshConnections);
-                cached = static_cast<bool>(cachedNavMeshData);
-            }
+            cachedNavMeshData = navMeshTilesCache.set(agentHalfExtents, changedTile, *recastMesh,
+                                                      offMeshConnections, std::move(navMeshData));
 
             if (!cachedNavMeshData)
             {

components/detournavigator/navmeshtilescache.cpp

@@ -1,5 +1,4 @@
 #include "navmeshtilescache.hpp"
-#include "exceptions.hpp"
 
 #include <osg/Stats>
 
@@ -32,16 +31,8 @@ namespace DetourNavigator
 
         ++mGetCount;
 
-        const auto agentValues = mValues.find(agentHalfExtents);
-        if (agentValues == mValues.end())
-            return Value();
-
-        const auto tileValues = agentValues->second.find(changedTile);
-        if (tileValues == agentValues->second.end())
-            return Value();
-
-        const auto tile = tileValues->second.mMap.find(NavMeshKeyView(recastMesh, offMeshConnections));
-        if (tile == tileValues->second.mMap.end())
+        const auto tile = mValues.find(std::make_tuple(agentHalfExtents, changedTile, NavMeshKeyView(recastMesh, offMeshConnections)));
+        if (tile == mValues.end())
             return Value();
 
         acquireItemUnsafe(tile->second);
@@ -71,76 +62,61 @@ namespace DetourNavigator
         };
 
         const auto iterator = mFreeItems.emplace(mFreeItems.end(), agentHalfExtents, changedTile, std::move(navMeshKey), itemSize);
-        const auto emplaced = mValues[agentHalfExtents][changedTile].mMap.emplace(iterator->mNavMeshKey, iterator);
+        const auto emplaced = mValues.emplace(std::make_tuple(agentHalfExtents, changedTile, NavMeshKeyRef(iterator->mNavMeshKey)), iterator);
 
         if (!emplaced.second)
         {
             mFreeItems.erase(iterator);
-            throw InvalidArgument("Set existing cache value");
+            acquireItemUnsafe(emplaced.first->second);
+            ++mGetCount;
+            ++mHitCount;
+            return Value(*this, emplaced.first->second);
         }
 
         iterator->mNavMeshData = std::move(value);
+        ++iterator->mUseCount;
         mUsedNavMeshDataSize += itemSize;
-        mFreeNavMeshDataSize += itemSize;
-
-        acquireItemUnsafe(iterator);
+        mBusyItems.splice(mBusyItems.end(), mFreeItems, iterator);
 
         return Value(*this, iterator);
     }
 
-    void NavMeshTilesCache::reportStats(unsigned int frameNumber, osg::Stats& stats) const
+    NavMeshTilesCache::Stats NavMeshTilesCache::getStats() const
     {
-        std::size_t navMeshCacheSize = 0;
-        std::size_t usedNavMeshTiles = 0;
-        std::size_t cachedNavMeshTiles = 0;
-        std::size_t hitCount = 0;
-        std::size_t getCount = 0;
-
+        Stats result;
         {
             const std::lock_guard<std::mutex> lock(mMutex);
-            navMeshCacheSize = mUsedNavMeshDataSize;
-            usedNavMeshTiles = mBusyItems.size();
-            cachedNavMeshTiles = mFreeItems.size();
-            hitCount = mHitCount;
-            getCount = mGetCount;
+            result.mNavMeshCacheSize = mUsedNavMeshDataSize;
+            result.mUsedNavMeshTiles = mBusyItems.size();
+            result.mCachedNavMeshTiles = mFreeItems.size();
+            result.mHitCount = mHitCount;
+            result.mGetCount = mGetCount;
         }
+        return result;
+    }
 
-        stats.setAttribute(frameNumber, "NavMesh CacheSize", navMeshCacheSize);
-        stats.setAttribute(frameNumber, "NavMesh UsedTiles", usedNavMeshTiles);
-        stats.setAttribute(frameNumber, "NavMesh CachedTiles", cachedNavMeshTiles);
-        stats.setAttribute(frameNumber, "NavMesh CacheHitRate", static_cast<double>(hitCount) / getCount * 100.0);
+    void NavMeshTilesCache::reportStats(unsigned int frameNumber, osg::Stats& out) const
+    {
+        const Stats stats = getStats();
+        out.setAttribute(frameNumber, "NavMesh CacheSize", stats.mNavMeshCacheSize);
+        out.setAttribute(frameNumber, "NavMesh UsedTiles", stats.mUsedNavMeshTiles);
+        out.setAttribute(frameNumber, "NavMesh CachedTiles", stats.mCachedNavMeshTiles);
+        out.setAttribute(frameNumber, "NavMesh CacheHitRate", static_cast<double>(stats.mHitCount) / stats.mGetCount * 100.0);
     }
 
     void NavMeshTilesCache::removeLeastRecentlyUsed()
     {
         const auto& item = mFreeItems.back();
 
-        const auto agentValues = mValues.find(item.mAgentHalfExtents);
-        if (agentValues == mValues.end())
-            return;
-
-        const auto tileValues = agentValues->second.find(item.mChangedTile);
-        if (tileValues == agentValues->second.end())
-            return;
-
-        const auto value = tileValues->second.mMap.find(item.mNavMeshKey);
-        if (value == tileValues->second.mMap.end())
+        const auto value = mValues.find(std::make_tuple(item.mAgentHalfExtents, item.mChangedTile, NavMeshKeyRef(item.mNavMeshKey)));
+        if (value == mValues.end())
             return;
 
         mUsedNavMeshDataSize -= item.mSize;
         mFreeNavMeshDataSize -= item.mSize;
 
-        tileValues->second.mMap.erase(value);
+        mValues.erase(value);
         mFreeItems.pop_back();
-
-        if (!tileValues->second.mMap.empty())
-            return;
-
-        agentValues->second.erase(tileValues);
-        if (!agentValues->second.empty())
-            return;
-
-        mValues.erase(agentValues);
     }
 
     void NavMeshTilesCache::acquireItemUnsafe(ItemIterator iterator)

components/detournavigator/navmeshtilescache.hpp

@@ -110,6 +110,14 @@ namespace DetourNavigator
         return lhs < rhs.mRef.get();
     }
 
+    template <class L, class R>
+    inline bool operator <(const std::tuple<osg::Vec3f, TilePosition, L>& lhs, const std::tuple<osg::Vec3f, TilePosition, R>& rhs)
+    {
+        const auto left = std::tie(std::get<0>(lhs), std::get<1>(lhs));
+        const auto right = std::tie(std::get<0>(rhs), std::get<1>(rhs));
+        return std::tie(left, std::get<2>(lhs)) < std::tie(right, std::get<2>(rhs));
+    }
+
     class NavMeshTilesCache
     {
     public:
@@ -188,6 +196,15 @@ namespace DetourNavigator
             ItemIterator mIterator;
         };
 
+        struct Stats
+        {
+            std::size_t mNavMeshCacheSize;
+            std::size_t mUsedNavMeshTiles;
+            std::size_t mCachedNavMeshTiles;
+            std::size_t mHitCount;
+            std::size_t mGetCount;
+        };
+
         NavMeshTilesCache(const std::size_t maxNavMeshDataSize);
 
         Value get(const osg::Vec3f& agentHalfExtents, const TilePosition& changedTile,
@@ -197,14 +214,11 @@ namespace DetourNavigator
             const RecastMesh& recastMesh, const std::vector<OffMeshConnection>& offMeshConnections,
             NavMeshData&& value);
 
+        Stats getStats() const;
+
         void reportStats(unsigned int frameNumber, osg::Stats& stats) const;
 
     private:
-        struct TileMap
-        {
-            std::map<NavMeshKeyRef, ItemIterator, std::less<>> mMap;
-        };
-
         mutable std::mutex mMutex;
         std::size_t mMaxNavMeshDataSize;
         std::size_t mUsedNavMeshDataSize;
@@ -213,7 +227,7 @@ namespace DetourNavigator
         std::size_t mGetCount;
         std::list<Item> mBusyItems;
         std::list<Item> mFreeItems;
-        std::map<osg::Vec3f, std::map<TilePosition, TileMap>> mValues;
+        std::map<std::tuple<osg::Vec3f, TilePosition, NavMeshKeyRef>, ItemIterator, std::less<>> mValues;
 
         void removeLeastRecentlyUsed();