hikyuu 2.6.8.3__py3-none-manylinux2014_aarch64.whl → 2.7.3__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/utilities/thread/algorithm.h

@@ -12,6 +12,8 @@
 #include <vector>
 #include "ThreadPool.h"
 #include "MQThreadPool.h"
+#include "StealThreadPool.h"
+#include "MQStealThreadPool.h"
 
 //----------------------------------------------------------------
 // Note: 除 ThreadPool/MQThreadPool 外，其他线程池由于使用
@@ -23,15 +25,17 @@ namespace hku {
 
 typedef std::pair<size_t, size_t> range_t;
 
-inline std::vector<range_t> parallelIndexRange(size_t start, size_t end) {
+inline std::vector<range_t> parallelIndexRange(size_t start, size_t end, size_t cpu_num = 0) {
     std::vector<std::pair<size_t, size_t>> ret;
     if (start >= end) {
         return ret;
     }
 
     size_t total = end - start;
-    size_t cpu_num = std::thread::hardware_concurrency();
-    if (cpu_num == 1) {
+    if (cpu_num == 0) {
+        cpu_num = std::thread::hardware_concurrency();
+    }
+    if (cpu_num <= 1) {
         ret.emplace_back(start, end);
         return ret;
     }
@@ -52,9 +56,13 @@ inline std::vector<range_t> parallelIndexRange(size_t start, size_t end) {
 }
 
 template <typename FunctionType, class TaskGroup = MQThreadPool>
-void parallel_for_index_void(size_t start, size_t end, FunctionType f) {
-    auto ranges = parallelIndexRange(start, end);
-    TaskGroup tg;
+void parallel_for_index_void(size_t start, size_t end, FunctionType f, int cpu_num = 0) {
+    auto ranges = parallelIndexRange(start, end, cpu_num);
+    if (ranges.empty()) {
+        return;
+    }
+
+    TaskGroup tg(cpu_num == 0 ? std::thread::hardware_concurrency() : cpu_num);
     for (size_t i = 0, total = ranges.size(); i < total; i++) {
         tg.submit([=, range = ranges[i]]() {
             for (size_t ix = range.first; ix < range.second; ix++) {
@@ -67,9 +75,14 @@ void parallel_for_index_void(size_t start, size_t end, FunctionType f) {
 }
 
 template <typename FunctionType, class TaskGroup = MQThreadPool>
-auto parallel_for_index(size_t start, size_t end, FunctionType f) {
-    auto ranges = parallelIndexRange(start, end);
-    TaskGroup tg;
+auto parallel_for_index(size_t start, size_t end, FunctionType f, size_t cpu_num = 0) {
+    std::vector<typename std::invoke_result<FunctionType, size_t>::type> ret;
+    auto ranges = parallelIndexRange(start, end, cpu_num);
+    if (ranges.empty()) {
+        return ret;
+    }
+
+    TaskGroup tg(cpu_num == 0 ? std::thread::hardware_concurrency() : cpu_num);
     std::vector<std::future<std::vector<typename std::invoke_result<FunctionType, size_t>::type>>>
       tasks;
     for (size_t i = 0, total = ranges.size(); i < total; i++) {
@@ -82,7 +95,6 @@ auto parallel_for_index(size_t start, size_t end, FunctionType f) {
         }));
     }
 
-    std::vector<typename std::invoke_result<FunctionType, size_t>::type> ret;
     for (auto& task : tasks) {
         auto one = task.get();
         for (auto&& value : one) {
@@ -94,15 +106,19 @@ auto parallel_for_index(size_t start, size_t end, FunctionType f) {
 }
 
 template <typename FunctionType, class TaskGroup = MQThreadPool>
-auto parallel_for_range(size_t start, size_t end, FunctionType f) {
-    auto ranges = parallelIndexRange(start, end);
-    TaskGroup tg;
+auto parallel_for_range(size_t start, size_t end, FunctionType f, size_t cpu_num = 0) {
+    typename std::invoke_result<FunctionType, range_t>::type ret;
+    auto ranges = parallelIndexRange(start, end, cpu_num);
+    if (ranges.empty()) {
+        return ret;
+    }
+
+    TaskGroup tg(cpu_num == 0 ? std::thread::hardware_concurrency() : cpu_num);
     std::vector<std::future<typename std::invoke_result<FunctionType, range_t>::type>> tasks;
     for (size_t i = 0, total = ranges.size(); i < total; i++) {
         tasks.emplace_back(tg.submit([func = f, range = ranges[i]]() { return func(range); }));
     }
 
-    typename std::invoke_result<FunctionType, range_t>::type ret;
     for (auto& task : tasks) {
         auto one = task.get();
         for (auto&& value : one) {
@@ -113,4 +129,38 @@ auto parallel_for_range(size_t start, size_t end, FunctionType f) {
     return ret;
 }
 
+template <typename FunctionType, class TaskGroup = ThreadPool>
+void parallel_for_index_void_single(size_t start, size_t end, FunctionType f, int cpu_num = 0) {
+    if (start >= end) {
+        return;
+    }
+
+    TaskGroup tg(cpu_num == 0 ? std::thread::hardware_concurrency() : cpu_num);
+    for (size_t i = start; i < end; i++) {
+        tg.submit([func = f, i]() { func(i); });
+    }
+    tg.join();
+    return;
+}
+
+template <typename FunctionType, class TaskGroup = ThreadPool>
+auto parallel_for_index_single(size_t start, size_t end, FunctionType f, size_t cpu_num = 0) {
+    std::vector<typename std::invoke_result<FunctionType, size_t>::type> ret;
+    if (start >= end) {
+        return ret;
+    }
+
+    TaskGroup tg(cpu_num == 0 ? std::thread::hardware_concurrency() : cpu_num);
+    std::vector<std::future<typename std::invoke_result<FunctionType, size_t>::type>> tasks;
+    for (size_t i = start; i < end; i++) {
+        tasks.emplace_back(tg.submit([func = f, i]() { return func(i); }));
+    }
+
+    for (auto& task : tasks) {
+        ret.push_back(std::move(task.get()));
+    }
+
+    return ret;
+}
+
 }  // namespace hku

hikyuu/include/hikyuu/version.h

@@ -12,13 +12,13 @@
 #define HKU_VERSION_H
 
 // clang-format off
-#define HKU_VERSION "2.6.8"
+#define HKU_VERSION "2.7.3"
 #define HKU_VERSION_MAJOR 2
-#define HKU_VERSION_MINOR 6
-#define HKU_VERSION_ALTER 8
-#define HKU_VERSION_BUILD 202509080133
+#define HKU_VERSION_MINOR 7
+#define HKU_VERSION_ALTER 3
+#define HKU_VERSION_BUILD 202601060312
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.6.8 master.be797426 (RELEASE)"
+#define HKU_VERSION_GIT "2.7.3 release.9c144edf (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */