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

hikyuu/include/hikyuu/utilities/thread/StealThreadPool.h

@@ -0,0 +1,297 @@
+/*
+ * StealThreadPool.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-9-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H
+#define HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H
+
+#include <future>
+#include <thread>
+#include <vector>
+#include "ThreadSafeQueue.h"
+#include "WorkStealQueue.h"
+#include "InterruptFlag.h"
+#include "../cppdef.h"
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
+namespace hku {
+
+/**
+ * @brief 分布偷取式线程池
+ * @note 主要用于存在递归情况，任务又创建任务加入线程池的情况，否则建议使用普通的线程池
+ * @details
+ * @ingroup ThreadPool
+ */
+#ifdef _MSC_VER
+class StealThreadPool {
+#else
+class HKU_UTILS_API StealThreadPool {
+#endif
+public:
+    /**
+     * 默认构造函数，创建和当前系统CPU数一致的线程数
+     */
+    StealThreadPool() : StealThreadPool(std::thread::hardware_concurrency()) {}
+
+    /**
+     * 构造函数，创建指定数量的线程
+     * @param n 指定的线程数
+     * @param until_empty 任务队列为空时，自动停止运行
+     */
+    explicit StealThreadPool(size_t n, bool until_empty = true)
+    : m_done(false), m_worker_num(n), m_running_until_empty(until_empty) {
+        try {
+            m_interrupt_flags.resize(m_worker_num);
+            for (int i = 0; i < m_worker_num; i++) {
+                // 创建工作线程及其任务队列
+                m_queues.emplace_back(new WorkStealQueue);
+            }
+            // 初始完毕所有线程资源后再启动线程
+            for (int i = 0; i < m_worker_num; i++) {
+                m_threads.emplace_back(&StealThreadPool::worker_thread, this, i);
+                m_thread_index[m_threads.back().get_id()] = i;
+            }
+        } catch (...) {
+            m_done = true;
+            throw;
+        }
+    }
+
+    /**
+     * 析构函数，等待并阻塞至线程池内所有任务完成
+     */
+    ~StealThreadPool() {
+        if (!m_done) {
+            join();
+        }
+        m_threads.clear();
+    }
+
+    /** 获取工作线程数 */
+    size_t worker_num() const {
+        return m_worker_num;
+    }
+
+    /** 剩余任务数 */
+    size_t remain_task_count() const {
+        if (m_done) {
+            return 0;
+        }
+        size_t total = m_master_work_queue.size();
+        for (size_t i = 0; i < m_worker_num; i++) {
+            total += m_queues[i]->size();
+        }
+        return total;
+    }
+
+    /** 先线程池提交任务后返回的对应 future 的类型 */
+    template <typename ResultType>
+    using task_handle = std::future<ResultType>;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+
+    /** 向线程池提交任务 */
+    template <typename FunctionType>
+    auto submit(FunctionType f) {
+        if (m_done) {
+            throw std::logic_error("You can't submit a task to the stopped StealThreadPool!!");
+        }
+
+        int index = -1;
+        auto iter = m_thread_index.find(std::this_thread::get_id());
+        if (iter != m_thread_index.end()) {
+            index = iter->second;
+        }
+
+        typedef typename std::invoke_result<FunctionType>::type result_type;
+        std::packaged_task<result_type()> task(f);
+        task_handle<result_type> res(task.get_future());
+        if (index != -1 && !m_interrupt_flags[index]) {
+            // 本地线程任务从前部入队列（递归成栈）
+            m_queues[index]->push_front(std::move(task));
+        } else {
+            m_master_work_queue.push(std::move(task));
+            m_cv.notify_one();
+        }
+        return res;
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    /** 返回线程池结束状态 */
+    bool done() const {
+        return m_done;
+    }
+
+    /**
+     * 等待各线程完成当前执行的任务后立即结束退出
+     */
+    void stop() {
+        if (m_done) {
+            return;
+        }
+
+        m_done = true;
+
+        // 同时加入结束任务指示，以便在dll退出时也能够终止
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_interrupt_flags[i].set();
+            m_queues[i]->push_front(FuncWrapper());
+        }
+
+        m_cv.notify_all();  // 唤醒所有工作线程
+        for (size_t i = 0; i < m_worker_num; i++) {
+            if (m_threads[i].joinable()) {
+                m_threads[i].join();
+            }
+        }
+
+        m_master_work_queue.clear();
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_queues[i]->clear();
+        }
+    }
+
+    /**
+     * 等待并阻塞至线程池内所有任务完成
+     * @note 至此线程池能工作线程结束不可再使用
+     */
+    void join() {
+        if (m_done) {
+            return;
+        }
+
+        // 指示各工作线程在未获取到工作任务时，停止运行
+        if (m_running_until_empty) {
+            while (true) {
+                if (m_master_work_queue.size() != 0) {
+                    std::this_thread::yield();
+                } else {
+                    bool can_quit = true;
+                    for (size_t i = 0; i < m_worker_num; i++) {
+                        if (!m_queues[i]->empty()) {
+                            can_quit = false;
+                            break;
+                        }
+                    }
+                    if (can_quit) {
+                        break;
+                    } else {
+                        std::this_thread::yield();
+                    }
+                }
+            }
+
+            m_done = true;
+            for (size_t i = 0; i < m_worker_num; i++) {
+                m_interrupt_flags[i].set();
+            }
+        }
+
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_master_work_queue.push(FuncWrapper());
+        }
+
+        // 唤醒所有工作线程
+        m_cv.notify_all();
+
+        // 等待线程结束
+        for (size_t i = 0; i < m_worker_num; i++) {
+            if (m_threads[i].joinable()) {
+                m_threads[i].join();
+            }
+        }
+
+        m_done = true;
+        m_master_work_queue.clear();
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_queues[i]->clear();
+        }
+    }
+
+private:
+    typedef FuncWrapper task_type;
+    std::atomic_bool m_done;       // 线程池全局需终止指示
+    size_t m_worker_num;           // 工作线程数量
+    bool m_running_until_empty;    // 任务队列为空时，自动停止运行
+    std::condition_variable m_cv;  // 信号量，无任务时阻塞线程并等待
+    std::mutex m_cv_mutex;         // 配合信号量的互斥量
+
+    std::vector<InterruptFlag> m_interrupt_flags;           // 工作线程状态
+    ThreadSafeQueue<task_type> m_master_work_queue;         // 主线程任务队列
+    std::vector<std::unique_ptr<WorkStealQueue>> m_queues;  // 任务队列（每个工作线程一个）
+    std::vector<std::thread> m_threads;                     // 工作线程
+    std::unordered_map<std::thread::id, int> m_thread_index;
+
+    void worker_thread(int index) {
+        while (!m_done && !m_interrupt_flags[index]) {
+            run_pending_task(index);
+        }
+    }
+
+    void run_pending_task(int index) {
+        // 从本地队列提前工作任务，如本地无任务则从主队列中提取任务
+        // 如果主队列中提取的任务是空任务，则认为需结束本线程，否则从其他工作队列中偷取任务
+        task_type task;
+        if (pop_task_from_local_queue(task, index)) {
+            if (!task.isNullTask()) {
+                task();
+            } else {
+                m_interrupt_flags[index].set();
+            }
+        } else if (pop_task_from_master_queue(task)) {
+            if (!task.isNullTask()) {
+                task();
+            } else {
+                m_interrupt_flags[index].set();
+            }
+        } else if (pop_task_from_other_thread_queue(task, index)) {
+            task();
+        } else {
+            std::unique_lock<std::mutex> lk(m_cv_mutex);
+            m_cv.wait(lk, [this] { return this->m_done || !this->m_master_work_queue.empty(); });
+        }
+    }
+
+    bool pop_task_from_master_queue(task_type& task) {
+        return m_master_work_queue.try_pop(task);
+    }
+
+    // cppcheck-suppress functionStatic // 屏蔽cppcheck转静态函数建议
+    bool pop_task_from_local_queue(task_type& task, int index) {
+        return m_queues[index]->try_pop(task);
+    }
+
+    bool pop_task_from_other_thread_queue(task_type& task, int index) {
+        for (int i = 0; i < m_worker_num; ++i) {
+            int pos = (index + i + 1) % m_worker_num;
+            if (pos != index && !m_interrupt_flags[pos] && m_queues[pos]->try_steal(task)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+} /* namespace hku */
+
+#endif /* HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H */

hikyuu/include/hikyuu/utilities/thread/ThreadPool.h

@@ -67,6 +67,7 @@ public:
         if (!m_done) {
             join();
         }
+        m_threads.clear();
     }
 
     /** 获取工作线程数 */

hikyuu/include/hikyuu/utilities/thread/WorkStealQueue.h

@@ -12,7 +12,7 @@
 #define HIKYUU_UTILITIES_THREAD_WORKSTEALQUEUE_H
 
 #include <deque>
-#include <mutex>
+#include <shared_mutex>
 #include "FuncWrapper.h"
 
 namespace hku {
@@ -24,7 +24,7 @@ class WorkStealQueue {
 private:
     typedef FuncWrapper data_type;
     std::deque<data_type> m_queue;
-    mutable std::mutex m_mutex;
+    mutable std::shared_mutex m_mutex;
 
 public:
     /** 构造函数 */
@@ -36,29 +36,30 @@ public:
 
     /** 将数据插入队列头部 */
     void push_front(data_type&& data) {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         m_queue.push_front(std::move(data));
     }
 
     /** 将数据插入队列尾部 */
     void push_back(data_type&& data) {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         m_queue.push_back(std::move(data));
     }
 
     /** 队列是否为空 */
     bool empty() const {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
         return m_queue.empty();
     }
 
     /** 队列大小，！未加锁，谨慎使用 */
     size_t size() const {
+        std::shared_lock<std::shared_mutex> lock(m_mutex);
         return m_queue.size();
     }
 
     void clear() {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         auto tmp = std::deque<data_type>();
         m_queue.swap(tmp);
     }
@@ -69,7 +70,7 @@ public:
      * @return 如果原本队列为空返回 false，否则为 true
      */
     bool try_pop(data_type& res) {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         if (m_queue.empty()) {
             return false;
         }
@@ -85,7 +86,7 @@ public:
      * @return 如果原本队列为空返回 false，否则为 true
      */
     bool try_steal(data_type& res) {
-        std::lock_guard<std::mutex> lock(m_mutex);
+        std::unique_lock<std::shared_mutex> lock(m_mutex);
         if (m_queue.empty()) {
             return false;
         }

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.7.0"
+#define HKU_VERSION "2.7.3"
 #define HKU_VERSION_MAJOR 2
 #define HKU_VERSION_MINOR 7
-#define HKU_VERSION_ALTER 0
-#define HKU_VERSION_BUILD 202511020003
+#define HKU_VERSION_ALTER 3
+#define HKU_VERSION_BUILD 202601060312
 #define HKU_VERSION_MODE "RELEASE"
-#define HKU_VERSION_GIT "2.7.0 release.3d6e5754 (RELEASE)"
+#define HKU_VERSION_GIT "2.7.3 release.9c144edf (RELEASE)"
 // clang-format on
 
 #endif /* HKU_VERSION_H */