Next

benchmark/0011.containers/.test_prop.toml

@@ -0,0 +1,3 @@
+["str_btree_set"]
+ignore = true
+

benchmark/0011.containers/str_btree_set/abseil_btree_set.cc

@@ -0,0 +1,54 @@
+#include <unordered_set>
+#include <string>
+#include <absl/container/btree_set.h>
+#include <fast_io.h>
+#include <fast_io_dsal/string.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<::std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::absl::btree_set<typename decltype(vec)::value_type> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/abseil_btree_set_fast_io.cc

@@ -0,0 +1,54 @@
+#include <unordered_set>
+#include <string>
+#include <absl/container/btree_set.h>
+#include <fast_io.h>
+#include <fast_io_dsal/string.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest()};
+	::fast_io::timer t(u8"str_btree_set");
+	::absl::btree_set<::fast_io::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/gentest.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <fast_io_dsal/vector.h>
+#include <fast_io_dsal/string.h>
+#include <random>
+
+template <typename T = ::fast_io::string>
+inline ::fast_io::vector<T> gentest()
+{
+	::fast_io::vector<T> vec;
+	::std::mt19937_64 eng;
+	::std::uniform_int_distribution<std::size_t> ud(0, 61);
+	::std::uniform_int_distribution<std::size_t> rlen(25, 30);
+	for (::std::size_t i{}; i != 1000000; ++i)
+	{
+		T tempstr;
+		::std::size_t n{rlen(eng)};
+		tempstr.reserve(n);
+		for (::std::size_t j{}; j != n; ++j)
+		{
+			char8_t ch(static_cast<char8_t>(ud(eng)));
+			if (ch < 10u)
+			{
+				ch += u8'0';
+			}
+			else if (ch < 36u)
+			{
+				ch = ch - 10u + u8'a';
+			}
+			else
+			{
+				ch = ch - 36u + u8'A';
+			}
+			tempstr.push_back(ch);
+		}
+		vec.emplace_back(::std::move(tempstr));
+	}
+	return vec;
+}

benchmark/0011.containers/str_btree_set/rustbtree/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "rustbtree"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.1"

benchmark/0011.containers/str_btree_set/rustbtree/src/main.rs

@@ -0,0 +1,77 @@
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use std::collections::BTreeSet;
+use std::time::Instant;
+
+fn generate_test_data() -> Vec<String> {
+    let mut vec = Vec::with_capacity(1_000_000);
+    let mut rng = StdRng::seed_from_u64(0xDEADBEEF); // deterministic seed
+
+    for _ in 0..1_000_000 {
+        let len = rng.random_range(25..=30); // replaces Uniform(8, 20)
+        let mut s = String::with_capacity(len);
+
+        for _ in 0..len {
+            let x = rng.random_range(0..=61); // replaces Uniform(0, 61)
+            let ch = match x {
+                x if x < 10 => (b'0' + x as u8) as char,
+                x if x < 36 => (b'a' + (x - 10) as u8) as char,
+                _ => (b'A' + (x - 36) as u8) as char,
+            };
+            s.push(ch);
+        }
+
+        vec.push(s);
+    }
+
+    vec
+}
+
+fn main() {
+    let vec = generate_test_data();
+    let start_total = Instant::now();
+    println!("str_btree_set test started");
+
+    let mut bset = BTreeSet::new();
+
+    let start_insert = Instant::now();
+    for s in &vec {
+        bset.insert(s.clone()); // cloning to move into BTreeSet
+    }
+    println!("insert_key: {:.2?}", start_insert.elapsed());
+
+    let mut count = 0;
+    let start_contains = Instant::now();
+    for s in &vec {
+        if bset.contains(s) {
+            count += 1;
+        }
+    }
+    println!("contains: {:.2?}", start_contains.elapsed());
+    // 🚀 Forward iteration benchmark
+    let mut total_size = 0;
+    let start_iter = Instant::now();
+    for s in &bset {
+        total_size += s.len();
+    }
+    println!(
+        "forward iteration total_size = {}, elapsed: {:.2?}",
+        total_size,
+        start_iter.elapsed()
+    );
+
+    // 🔄 Reverse iteration benchmark
+    let mut total_size = 0;
+    let start_rev_iter = Instant::now();
+    for s in bset.iter().rev() {
+        total_size += s.len();
+    }
+    println!(
+        "reverse iteration total_size = {}, elapsed: {:.2?}",
+        total_size,
+        start_rev_iter.elapsed()
+    );
+
+    println!("count = {}", count);
+    println!("total time: {:.2?}", start_total.elapsed());
+}

benchmark/0011.containers/str_btree_set/std_set.cc

@@ -0,0 +1,52 @@
+#include <set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<::std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::set<typename decltype(vec)::value_type> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/std_set_fast_io.cc

@@ -0,0 +1,52 @@
+#include <set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::set<::fast_io::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/std_unordered_set.cc

@@ -0,0 +1,30 @@
+#include <unordered_set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::unordered_set<::std::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+}