registry/benchmark: rollback optimized remove/erase (benchmarks have shown that they are not worth it)

src/entt/entity/registry.hpp

@@ -769,15 +769,10 @@ public:
         const auto cpools = std::make_tuple(assure<Component>()...);
         size_type count{};
 
-        if constexpr(is_iterator_type_v<typename basic_common_type::iterator, It>) {
-            for(; first != last; ++first) {
-                const auto entity = *first;
-                ENTT_ASSERT(valid(entity), "Invalid entity");
-                count += (std::get<storage_type<Component> *>(cpools)->remove(entity, this) + ...);
-            }
-        } else {
-            ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); }), "Invalid entity");
-            count += (std::get<storage_type<Component> *>(cpools)->remove(first, last, this) + ...);
+        for(; first != last; ++first) {
+            const auto entity = *first;
+            ENTT_ASSERT(valid(entity), "Invalid entity");
+            count += (std::get<storage_type<Component> *>(cpools)->remove(entity, this) + ...);
         }
 
         return count;
@@ -815,15 +810,10 @@ public:
         static_assert(sizeof...(Component) > 0, "Provide one or more component types");
         const auto cpools = std::make_tuple(assure<Component>()...);
 
-        if constexpr(is_iterator_type_v<typename basic_common_type::iterator, It>) {
-            for(; first != last; ++first) {
-                const auto entity = *first;
-                ENTT_ASSERT(valid(entity), "Invalid entity");
-                (std::get<storage_type<Component> *>(cpools)->erase(entity, this), ...);
-            }
-        } else {
-            ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); }), "Invalid entity");
-            (std::get<storage_type<Component> *>(cpools)->erase(first, last, this), ...);
+        for(; first != last; ++first) {
+            const auto entity = *first;
+            ENTT_ASSERT(valid(entity), "Invalid entity");
+            (std::get<storage_type<Component> *>(cpools)->erase(entity, this), ...);
         }
     }
 

test/benchmark/benchmark.cpp

@@ -127,7 +127,7 @@ TEST(Benchmark, Erase) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Removing 1000000 components from their entities" << std::endl;
+    std::cout << "Erasing 1000000 components from their entities" << std::endl;
 
     registry.create(entities.begin(), entities.end());
     registry.insert<int>(entities.begin(), entities.end());
@@ -145,14 +145,14 @@ TEST(Benchmark, EraseMany) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Removing 999999 components from their entities at once" << std::endl;
+    std::cout << "Erasing 1000000 components from their entities at once" << std::endl;
 
     registry.create(entities.begin(), entities.end());
     registry.insert<int>(entities.begin(), entities.end());
 
     timer timer;
     auto view = registry.view<int>();
-    registry.erase<int>(++view.begin(), view.end());
+    registry.erase<int>(view.begin(), view.end());
     timer.elapsed();
 }
 
@@ -178,14 +178,28 @@ TEST(Benchmark, RemoveMany) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Removing 999999 components from their entities at once" << std::endl;
+    std::cout << "Removing 1000000 components from their entities at once" << std::endl;
 
     registry.create(entities.begin(), entities.end());
     registry.insert<int>(entities.begin(), entities.end());
 
     timer timer;
     auto view = registry.view<int>();
-    registry.remove<int>(++view.begin(), view.end());
+    registry.remove<int>(view.begin(), view.end());
+    timer.elapsed();
+}
+
+TEST(Benchmark, Clear) {
+    entt::registry registry;
+    std::vector<entt::entity> entities(1000000);
+
+    std::cout << "Clearing 1000000 components from their entities" << std::endl;
+
+    registry.create(entities.begin(), entities.end());
+    registry.insert<int>(entities.begin(), entities.end());
+
+    timer timer;
+    registry.clear<int>();
     timer.elapsed();
 }
 
@@ -249,7 +263,7 @@ TEST(Benchmark, DestroyMany) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Destroying 1000000 entities" << std::endl;
+    std::cout << "Destroying 1000000 entities at once" << std::endl;
 
     registry.create(entities.begin(), entities.end());
     registry.insert<int>(entities.begin(), entities.end());
@@ -260,6 +274,20 @@ TEST(Benchmark, DestroyMany) {
     timer.elapsed();
 }
 
+TEST(Benchmark, DestroyManyFastPath) {
+    entt::registry registry;
+    std::vector<entt::entity> entities(1000000);
+
+    std::cout << "Destroying 1000000 entities at once, fast path" << std::endl;
+
+    registry.create(entities.begin(), entities.end());
+    registry.insert<int>(entities.begin(), entities.end());
+
+    timer timer;
+    registry.destroy(entities.begin(), entities.end());
+    timer.elapsed();
+}
+
 TEST(Benchmark, IterateSingleComponent1M) {
     entt::registry registry;