Implement deque push_back/pop_back/push_front/pop_front

benchmark/0011.containers/deque/0001.push_back/fast_io.cc

@@ -0,0 +1,26 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/deque.h>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::deque");
+	fast_io::deque<std::size_t> deq;
+	constexpr std::size_t n{100000000};
+	{
+		fast_io::timer tm1(u8"push_back");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			deq.push_back(i);
+		}
+	}
+	::std::size_t sum{};
+	{
+		fast_io::timer tm1(u8"loop");
+		for (auto const e : deq)
+		{
+			sum += e;
+		}		
+	}
+	::fast_io::io::perrln("sum=",sum);
+}

benchmark/0011.containers/deque/0001.push_back/fast_io_vec.cc

@@ -0,0 +1,26 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/vector.h>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::vector");
+	fast_io::vector<std::size_t> vec;
+	constexpr std::size_t n{100000000};
+	{
+		fast_io::timer tm1(u8"push_back");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			vec.push_back(i);
+		}
+	}
+	::std::size_t sum{};
+	{
+		fast_io::timer tm1(u8"loop");
+		for (auto const e : vec)
+		{
+			sum += e;
+		}		
+	}
+	::fast_io::io::perrln("sum=",sum);
+}

benchmark/0011.containers/deque/0001.push_back/fast_io_vec_reserve.cc

@@ -0,0 +1,27 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <fast_io_dsal/vector.h>
+
+int main()
+{
+	fast_io::timer tm(u8"fast_io::vector reserve");
+	fast_io::vector<std::size_t> vec;
+	constexpr std::size_t n{100000000};
+	vec.reserve(n);
+	{
+		fast_io::timer tm1(u8"push_back");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			vec.push_back(i);
+		}
+	}
+	::std::size_t sum{};
+	{
+		fast_io::timer tm1(u8"loop");
+		for (auto const e : vec)
+		{
+			sum += e;
+		}		
+	}
+	::fast_io::io::perrln("sum=",sum);
+}

benchmark/0011.containers/deque/0001.push_back/std.cc

@@ -0,0 +1,26 @@
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include <deque>
+
+int main()
+{
+	fast_io::timer tm(u8"std::deque");
+	std::deque<std::size_t> deq;
+	constexpr std::size_t n{100000000};
+	{
+		fast_io::timer tm1(u8"push_back");
+		for (std::size_t i{}; i != n; ++i)
+		{
+			deq.push_back(i);
+		}
+	}
+	::std::size_t sum{};
+	{
+		fast_io::timer tm1(u8"loop");
+		for (auto const e : deq)
+		{
+			sum += e;
+		}		
+	}
+	::fast_io::io::perrln("sum=",sum);
+}

fuzzing/0007.containers/deque/fuzz_deque.cc

@@ -0,0 +1,64 @@
+#include <fast_io.h>
+#include <fast_io_dsal/deque.h>
+#include <deque>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <ranges>
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const *data, size_t size)
+{
+	::fast_io::deque<std::size_t> dq;
+	std::deque<std::size_t> ref;
+
+	// Interpret input as a sequence of operations
+	for (size_t i{}; i != size; ++i)
+	{
+		uint8_t op = data[i] & 0x3u; // 4 operations
+		std::size_t value = i;       // deterministic, stable
+
+		switch (op)
+		{
+		case 0: // push_back
+
+			dq.push_back(value);
+			ref.push_back(value);
+			break;
+
+		case 1: // push_front
+
+			dq.push_front(value);
+			ref.push_front(value);
+			break;
+
+		case 2: // pop_back
+			if (!ref.empty())
+			{
+
+				dq.pop_back();
+				ref.pop_back();
+			}
+			break;
+
+		case 3: // pop_front
+			if (!ref.empty())
+			{
+
+				dq.pop_front();
+				ref.pop_front();
+			}
+			break;
+		}
+	}
+
+	// Validate correctness
+	if (dq.size() != ref.size())
+	{
+		__builtin_trap();
+	}
+	if (!std::ranges::equal(dq, ref))
+	{
+		__builtin_trap();
+	}
+	return 0;
+}

fuzzing/0007.containers/deque/fuzz_deque_clear.cc

@@ -0,0 +1,80 @@
+#include <fast_io_dsal/deque.h>
+#include <deque>
+#include <cstddef>
+#include <cstdint>
+#include <ranges>
+
+extern "C" int LLVMFuzzerTestOneInput(uint8_t const* data, size_t size)
+{
+    // Require large inputs to trigger growth/balancing
+    if (size < 4096)
+        return 0;
+
+    ::fast_io::deque<std::size_t> dq;
+    std::deque<std::size_t> ref;
+
+    for (size_t i{}; i != size; ++i)
+    {
+        uint8_t raw = data[i];
+        uint8_t op = raw % 6u;  // 6 operations
+        std::size_t value = i;
+
+        bool allow_clear =
+            dq.size() >= 4096 || (raw == 0xFF);  
+            // 1/256 chance of early clear
+
+        switch (op)
+        {
+        case 0: // push_back
+            dq.push_back(value);
+            ref.push_back(value);
+            break;
+
+        case 1: // push_front
+            dq.push_front(value);
+            ref.push_front(value);
+            break;
+
+        case 2: // pop_back
+            if (!ref.empty())
+            {
+                dq.pop_back();
+                ref.pop_back();
+            }
+            break;
+
+        case 3: // pop_front
+            if (!ref.empty())
+            {
+                dq.pop_front();
+                ref.pop_front();
+            }
+            break;
+
+        case 4: // clear()
+            if (allow_clear)
+            {
+                dq.clear();
+                ref.clear();
+            }
+            break;
+
+        case 5: // clear_destroy()
+            if (allow_clear)
+            {
+                dq.clear_destroy();
+                ref.clear();
+            }
+            break;
+        }
+    }
+
+    // Validate correctness
+    if (dq.size() != ref.size())
+        __builtin_trap();
+
+    if (!std::ranges::equal(dq, ref))
+        __builtin_trap();
+
+    return 0;
+}

include/fast_io_core_impl/allocation/c_malloc.h

@@ -5,6 +5,7 @@
 #elif __has_include(<malloc_np.h>)
 #include <malloc_np.h>
 #endif
+#include <cstdlib>
 
 namespace fast_io
 {
@@ -197,16 +198,40 @@ class c_malloc_allocator
 			::fast_io::noexcept_call(_aligned_free, p);
 		}
 	}
+#elif !defined(__MSDOS__) && 0
+	static inline void *allocate_aligned(::std::size_t alignment, ::std::size_t n) noexcept
+	{
+		if (n == 0)
+		{
+			n = 1;
+		}
+		void *p =
+#if FAST_IO_HAS_BUILTIN(__builtin_aligned_alloc)
+			__builtin_aligned_alloc(alignment, n)
+#else
+			::std::aligned_alloc(alignment, n)
+#endif
+			;
+		if (p == nullptr)
+		{
+			::fast_io::fast_terminate();
+		}
+		return p;
+	}
+	static inline void deallocate_aligned(void *p, ::std::size_t) noexcept
+	{
+		deallocate(p);
+	}
 #endif
 	static inline void deallocate(void *p) noexcept
 	{
 		if (p == nullptr)
 		{
 			return;
 		}
-		
+
 #if FAST_IO_HAS_BUILTIN(__builtin_free)
-        __builtin_free
+		__builtin_free
 #else
 		::std::free
 #endif