update: cleanup the group extend code

src/core/group/internal/group.cc

@@ -17,106 +17,125 @@ using klotski::mover::MaskMover;
 using klotski::group::GROUP_DATA;
 using klotski::group::PATTERN_DATA;
 
-template <typename MFunc, typename RFunc>
+template <typename MF, typename RF>
-KLSK_NOINLINE static void group_extend(RawCode seed, const size_t reserve, MFunc add_mirror, RFunc release) {
+KLSK_NOINLINE static void extend(RawCode seed, const size_t size, MF add_mirror, RF release) {
-    std::vector<RawCode> codes;
+    std::vector<RawCode> queue, mirrors;
-    std::vector<RawCode> mirrors;
+    phmap::flat_hash_map<RawCode, uint64_t> cases;
-    phmap::flat_hash_map<RawCode, uint64_t> cases; // <code, hint>
 
-    codes.reserve(reserve);
+    queue.reserve(size); mirrors.reserve(size);
-    mirrors.reserve(reserve); // TODO: cal max size-coff
+    cases.reserve(static_cast<size_t>(static_cast<double>(size) * 1.56)); // reduce load factor
-    cases.reserve(static_cast<size_t>(reserve * 1.56));
 
-    auto core = MaskMover([&codes, &cases, &mirrors, add_mirror](RawCode code, uint64_t hint) {
+    auto mover = MaskMover([&queue, &cases, &mirrors, add_mirror](RawCode code, uint64_t hint) {
         if (const auto [iter, ret] = cases.try_emplace(code, hint); !ret) {
             iter->second |= hint; // update hint
             return;
         }
-        codes.emplace_back(code);
+        queue.emplace_back(code);
         add_mirror(code, [&cases, &mirrors](RawCode mirror) {
-            cases.emplace(mirror, 0);
+            cases.emplace(mirror, 0); // without hint
             mirrors.emplace_back(mirror);
         });
     });
 
-    uint64_t offset = 0;
+    queue.emplace_back(seed);
-    codes.emplace_back(seed);
+    cases.emplace(seed, 0);
-    cases.emplace(seed, 0); // without hint
     add_mirror(seed, [&mirrors, &cases](RawCode mirror) {
-        cases.emplace(mirror, 0);
+        cases.emplace(mirror, 0); // without hint
         mirrors.emplace_back(mirror);
     });
-    while (offset != codes.size()) {
-        const auto curr = codes[offset++];
-        core.next_cases(curr, cases.find(curr)->second);
-    }
 
-    for (const auto code : codes) {
+    size_t offset = 0;
-        release(code);
+    while (offset != queue.size()) {
-    }
+        const auto curr = queue[offset++];
-    for (const auto code : mirrors) {
+        mover.next_cases(curr, cases.find(curr)->second);
-        release(code);
     }
+    for (const auto code : queue) { release(code); }
+    for (const auto code : mirrors) { release(code); }
 }
 
 static RangesUnion extend_type_common(RawCode seed, size_t reserve) {
-    RangesUnion result {};
+    RangesUnion data {};
-    group_extend(seed, reserve, [](RawCode, auto) {}, [&result](RawCode code) {
+    extend(seed, reserve, [](RawCode, auto) {}, [&data](const RawCode raw_code) {
-        const auto common_code = code.to_common_code().unwrap();
+        const auto code = raw_code.to_common_code().unwrap();
-        result.ranges(common_code >> 32).emplace_back(static_cast<uint32_t>(common_code));
+        data.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
-    return result;
+    return data;
 }
 
 static RangesUnion extend_type_hor(RawCode seed, size_t reserve) {
-    RangesUnion result {};
+
-    group_extend(seed, reserve, [](const RawCode code, auto callback) {
+    // size_t size_a = static_cast<size_t>(static_cast<double>(size) * 0.500892) + 11;
+    // size_t size_b = static_cast<size_t>(static_cast<double>(size) * 0.499108) + 10;
+
+    RangesUnion data {};
+
+    // TODO: how to reserve
+    // size_t val = reserve / 8;
+    //
+    // data.ranges(0).reserve(val);
+    // data.ranges(1).reserve(val);
+    // data.ranges(2).reserve(val);
+    //
+    // data.ranges(4).reserve(val);
+    // data.ranges(5).reserve(val);
+    // data.ranges(6).reserve(val);
+    //
+    // data.ranges(8).reserve(val);
+    // data.ranges(9).reserve(val);
+    // data.ranges(10).reserve(val);
+    //
+    // data.ranges(12).reserve(val);
+    // data.ranges(13).reserve(val);
+    // data.ranges(14).reserve(val);
+
+    extend(seed, reserve, [](const RawCode code, auto callback) {
         if (const auto mirror = code.to_horizontal_mirror(); mirror != code) {
             callback(mirror);
         }
-    }, [&result](RawCode code) {
+    }, [&data](const RawCode raw_code) {
-        const auto common_code = code.to_common_code().unwrap();
+        const auto code = raw_code.to_common_code().unwrap();
-        result.ranges(common_code >> 32).emplace_back(static_cast<uint32_t>(common_code));
+        data.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
-    return result;
+
+    return data;
 }
 
 static RangesUnion extend_type_ver(RawCode seed, size_t reserve) {
-    RangesUnion result {};
+    RangesUnion data {};
-    group_extend(seed, reserve, [](const RawCode code, auto callback) {
+    extend(seed, reserve, [](const RawCode code, auto callback) {
         callback(code.to_vertical_mirror());
-    }, [&result](RawCode code) {
+    }, [&data](const RawCode raw_code) {
-        const auto common_code = code.to_common_code().unwrap();
+        const auto code = raw_code.to_common_code().unwrap();
-        result.ranges(common_code >> 32).emplace_back(static_cast<uint32_t>(common_code));
+        data.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
-    return result;
+    return data;
 }
 
 static RangesUnion extend_type_diag(RawCode seed, size_t reserve) {
-    RangesUnion result {};
+    RangesUnion data {};
-    group_extend(seed, reserve, [](const RawCode code, auto callback) {
+    extend(seed, reserve, [](const RawCode code, auto callback) {
         callback(code.to_diagonal_mirror());
-    }, [&result](RawCode code) {
+    }, [&data](const RawCode raw_code) {
-        const auto common_code = code.to_common_code().unwrap();
+        const auto code = raw_code.to_common_code().unwrap();
-        result.ranges(common_code >> 32).emplace_back(static_cast<uint32_t>(common_code));
+        data.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
-    return result;
+    return data;
 }
 
 static RangesUnion extend_type_x(RawCode seed, size_t reserve) {
-    RangesUnion result {};
+    RangesUnion data {};
-    group_extend(seed, reserve, [](const RawCode code, auto callback) {
+    extend(seed, reserve, [](const RawCode code, auto callback) {
         const auto mirror_1 = code.to_vertical_mirror();
         callback(mirror_1);
         if (const auto mirror_2 = code.to_horizontal_mirror(); mirror_2 != code) {
             callback(mirror_2);
             callback(mirror_1.to_horizontal_mirror());
         }
-    }, [&result](RawCode code) {
+    }, [&data](const RawCode raw_code) {
-        const auto common_code = code.to_common_code().unwrap();
+        const auto code = raw_code.to_common_code().unwrap();
-        result.ranges(common_code >> 32).emplace_back(static_cast<uint32_t>(common_code));
+        data.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
-    return result;
+    return data;
 }
 
 template <typename MFunc, typename RFunc>
@@ -163,25 +182,14 @@ KLSK_NOINLINE static void spawn_pattern(RawCode seed, const size_t reserve, MFun
 }
 
 KLSK_NOINLINE static void spawn_full_pattern(RawCode seed, const size_t reserve, RangesUnion &output) {
-    spawn_pattern(seed, reserve, [](const RawCode code, auto callback) {
+    spawn_pattern(seed, reserve, [](RawCode, auto) {}, [&output](RawCode raw_code) {
-        // const auto mirror_1 = code.to_vertical_mirror();
-        // callback(mirror_1);
-        // if (const auto mirror_2 = code.to_horizontal_mirror(); mirror_2 != code) {
-        //     callback(mirror_2);
-        //     callback(mirror_1.to_horizontal_mirror());
-        // }
-    }, [&output](RawCode raw_code) {
         const auto code = raw_code.to_common_code().unwrap();
         output.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
     });
 }
 
 KLSK_NOINLINE static void spawn_hor_pattern(RawCode seed, const size_t reserve, RangesUnion &output) {
-    spawn_pattern(seed, reserve, [](const RawCode code, auto callback) {
+    spawn_pattern(seed, reserve, [](RawCode, auto) {}, [&output](RawCode raw_code) {
-        // if (const auto mirror = code.to_horizontal_mirror(); mirror != code) {
-        //     callback(mirror);
-        // }
-    }, [&output](RawCode raw_code) {
         const auto code = raw_code.to_common_code().unwrap();
         output.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
 
@@ -191,9 +199,7 @@ KLSK_NOINLINE static void spawn_hor_pattern(RawCode seed, const size_t reserve,
 }
 
 KLSK_NOINLINE static void spawn_ver_pattern(RawCode seed, const size_t reserve, RangesUnion &output) {
-    spawn_pattern(seed, reserve, [](const RawCode code, auto callback) {
+    spawn_pattern(seed, reserve, [](RawCode, auto) {}, [&output](RawCode raw_code) {
-        // callback(code.to_vertical_mirror());
-    }, [&output](RawCode raw_code) {
         const auto code = raw_code.to_common_code().unwrap();
         output.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
 
@@ -204,17 +210,6 @@ KLSK_NOINLINE static void spawn_ver_pattern(RawCode seed, const size_t reserve,
 
 KLSK_NOINLINE static void spawn_ord_pattern(RawCode seed, const size_t reserve, RangesUnion &output) {
     spawn_pattern(seed, reserve, [](RawCode, auto) {}, [&output](RawCode raw_code) {
-
-        // auto add_case = [&output](RawCode r_code) {
-        //     const auto code = r_code.to_common_code().unwrap();
-        //     output.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));
-        // };
-        //
-        // add_case(raw_code);
-        // add_case(raw_code.to_vertical_mirror());
-        // add_case(raw_code.to_horizontal_mirror());
-        // add_case(raw_code.to_diagonal_mirror());
-
         const auto code = raw_code.to_common_code().unwrap();
         output.ranges(code >> 32).emplace_back(static_cast<uint32_t>(code));