rewrite big_new to big_alloc

Author: adamant-pwn

cp-algo/math/cvector.hpp

@@ -2,7 +2,7 @@
 #define CP_ALGO_MATH_CVECTOR_HPP
 #include "../util/complex.hpp"
 #include "../util/checkpoint.hpp"
-#include  "../util/new_big.hpp"
+#include "../util/big_alloc.hpp"
 #include <experimental/simd>
 #include <ranges>
 
@@ -18,28 +18,20 @@ namespace cp_algo::math::fft {
     static constexpr vpoint vi = {vz, vz + 1};
 
     struct cvector {
-        vpoint *r;
-        size_t sz;
+        std::vector<vpoint, big_alloc<vpoint>> r;
         cvector(size_t n) {
-            sz = std::max(flen, std::bit_ceil(n));
-            r = new_big<vpoint>(sz / flen);
+            n = std::max(flen, std::bit_ceil(n));
+            r.resize(n / flen);
             checkpoint("cvector create");
         }
         cvector(cvector const& t) {
-            sz = t.sz;
-            r = new_big<vpoint>(sz / flen);
-            memcpy(r, t.r, (sz / flen) * sizeof(vpoint));
-            checkpoint("cvector copy");
-        }
-        cvector(cvector&& t) noexcept {
-            sz = t.sz;
-            r = std::exchange(t.r, nullptr);
-        }
-        ~cvector() noexcept {
-            if(r) {
-                delete_big(r, sz / flen);
+            r.resize(t.r.size());
+            for(size_t i = 0; i < r.size(); i++) {
+                r[i] = {vftype(t.r[i].real()), vftype(t.r[i].imag())};
             }
+            checkpoint("cvector copy");
         }
+        cvector(cvector&& t) = delete;
 
         vpoint& at(size_t k) {return r[k / flen];}
         vpoint at(size_t k) const {return r[k / flen];}
@@ -62,7 +54,7 @@ namespace cp_algo::math::fft {
         }
 
         size_t size() const {
-            return sz;
+            return flen * r.size();
         }
         static size_t eval_arg(size_t n) {
             if(n < pre_evals) {
@@ -90,15 +82,15 @@ namespace cp_algo::math::fft {
             }
         }
         static void exec_on_roots(size_t n, size_t m, auto &&callback) {
-            point cur;
+            point cur = {1, 0};
             point arg = root(n, 1);
             for(size_t i = 0; i < m; i++) {
-                if(i % 32 == 0) {
-                    cur = root(n / 32, i / 32);
+                callback(i, cur);
+                if(i % 64 == 63) {
+                    cur = root(n / 64, i / 64 + 1);
                 } else {
                     cur *= arg;
                 }
-                callback(i, cur);
             }
         }
         template<int step = 1>
@@ -207,7 +199,7 @@ namespace cp_algo::math::fft {
             }
             checkpoint("fft");
         }
-        static constexpr size_t pre_roots = 1 << 15;
+        static constexpr size_t pre_roots = 1 << 14;
         static constexpr size_t pre_evals = 1 << 16;
         static constexpr std::array<point, pre_roots> roots = []() {
             std::array<point, pre_roots> res = {};

cp-algo/math/fft.hpp

@@ -165,8 +165,8 @@ namespace cp_algo::math::fft {
             std::min(k, size(a)) + std::min(k, size(b)) - 1
         ) / 2);
         auto A = dft<base>(a | std::views::take(k), n);
-        a.resize(k);
-        checkpoint("resize a");
+        a.assign(k, 0);
+        checkpoint("reset a");
         if(&a == &b) {
             A.mul(A, a, k);
         } else {

cp-algo/math/poly.hpp

@@ -13,10 +13,10 @@
 #include <vector>
 #include <list>
 namespace cp_algo::math {
-    template<typename T>
+    template<typename T, class Alloc = big_alloc<T>>
     struct poly_t {
         using base = T;
-        std::vector<T> a;
+        std::vector<T, Alloc> a;
 
         poly_t& normalize() {
             while(deg() >= 0 && lead() == base(0)) {
@@ -27,8 +27,8 @@ namespace cp_algo::math {
 
         poly_t(){}
         poly_t(T a0): a{a0} {normalize();}
-        poly_t(std::vector<T> const& t): a(t) {normalize();}
-        poly_t(std::vector<T>&& t): a(std::move(t)) {normalize();}
+        poly_t(auto const& t): a(t.begin(), t.end()) {normalize();}
+        poly_t(std::vector<T, Alloc> &&t): a(std::move(t)) {normalize();}
 
         poly_t& negate_inplace() {
             std::ranges::transform(a, begin(a), std::negate{});

cp-algo/util/big_alloc.hpp

@@ -0,0 +1,55 @@
+#ifndef CP_ALGO_UTIL_big_alloc_HPP
+#define CP_ALGO_UTIL_big_alloc_HPP
+
+#include <cstddef>
+#include <iostream>
+
+// Single macro to detect POSIX platforms (Linux, Unix, macOS)
+#if defined(__linux__) || defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#  define CP_ALGO_USE_MMAP 1
+#  include <sys/mman.h>
+#else
+#  define CP_ALGO_USE_MMAP 0
+#endif
+
+namespace cp_algo {
+    template <typename T>
+    class big_alloc: public std::allocator<T> {
+        public:
+        using value_type = T;
+        using base = std::allocator<T>;
+
+        big_alloc() noexcept = default;
+
+        template <typename U>
+        big_alloc(const big_alloc<U>&) noexcept {}
+
+#if CP_ALGO_USE_MMAP
+        [[nodiscard]] T* allocate(std::size_t n) {
+            if(n * sizeof(T) < 4 * 1024 * 1024) {
+                return base::allocate(n);
+            }
+            n *= sizeof(T);
+            void* raw = mmap(nullptr, n,
+                            PROT_READ | PROT_WRITE,
+                            MAP_PRIVATE | MAP_ANONYMOUS,
+                            -1, 0);
+            madvise(raw, n, MADV_HUGEPAGE);
+            madvise(raw, n, MADV_POPULATE_WRITE);
+            return static_cast<T*>(raw);
+        }
+#endif
+
+#if CP_ALGO_USE_MMAP
+        void deallocate(T* p, std::size_t n) noexcept {
+            if(n * sizeof(T) < 4 * 1024 * 1024) {
+                return base::deallocate(p, n);
+            }
+            if(p) {
+                munmap(p, n * sizeof(T));
+            }
+        }
+#endif
+    };
+}
+#endif // CP_ALGO_UTIL_big_alloc_HPP

cp-algo/util/complex.hpp

@@ -8,7 +8,7 @@ namespace cp_algo {
     struct complex {
         using value_type = T;
         T x, y;
-        constexpr complex() {}
+        constexpr complex(): x(), y() {}
         constexpr complex(T x): x(x), y() {}
         constexpr complex(T x, T y): x(x), y(y) {}
         complex& operator *= (T t) {x *= t; y *= t; return *this;}

cp-algo/util/new_big.hpp

@@ -54,15 +54,15 @@ string matches(string const& A, string const& B, char wild = '*') {
             project[1][i] = conj(project[0][i]);
         }
     }
-    project[0][wild] = project[1][wild] = 0;
+    project[0][(int)wild] = project[1][(int)wild] = 0;
     vector<cvector> P;
     P.emplace_back(size(A));
     P.emplace_back(size(A));
     for(auto [i, c]: A | views::enumerate) {
-        P[0].set(i, project[0][c]);
+        P[0].set(i, project[0][(int)c]);
     }
     for(auto [i, c]: B | views::reverse | views::enumerate) {
-        P[1].set(i, project[1][c]);
+        P[1].set(i, project[1][(int)c]);
     }
     cp_algo::checkpoint("cvector fill");
     semicorr(P[0], P[1]);