hikyuu 2.7.3__py3-none-win_amd64.whl → 2.7.5__py3-none-win_amd64.whl

hikyuu/include/hikyuu/utilities/LruCache.h

@@ -0,0 +1,299 @@
+/*
+ *  Copyright (c) 2026 hikyuu.org
+ *
+ *  Created on: 2026-01-18
+ *      Author: fasiondog
+ */
+
+#pragma once
+#include <unordered_map>
+#include <list>
+#include <mutex>
+#include <shared_mutex>
+#include <atomic>
+#include <optional>
+
+namespace hku {
+
+class NullLock {
+public:
+    void lock() noexcept {}
+    void unlock() noexcept {}
+    bool try_lock() noexcept {
+        return true;
+    }
+    void lock_shared() noexcept {}
+    void unlock_shared() noexcept {}
+    bool try_lock_shared() noexcept {
+        return true;
+    }
+};
+
+/**
+ * @brief LRU (Least Recently Used)
+ * 缓存实现(非严格意义LRU以便提升并发读取性能)
+ * @tparam KeyType 键的类型，必须支持哈希和相等比较
+ * @tparam ValueType 值的类型，必须支持拷贝和移动操作
+ */
+template <typename KeyType, typename ValueType, class Lock = NullLock>
+class LruCache final {
+public:
+    using key_type = KeyType;
+    using value_type = ValueType;
+    using size_type = size_t;
+    typedef Lock lock_type;
+    using UniqueGuard = std::unique_lock<lock_type>;
+    using SharedGuard = std::shared_lock<lock_type>;
+
+    // 存储结构：值 + 原子脏标记（标记是否被get访问过，需要更新LRU顺序）
+    using CacheValue = std::pair<value_type, std::atomic<bool>>;
+    using LruList = std::list<key_type>;
+    using CacheMap =
+      std::unordered_map<key_type, std::pair<typename LruList::iterator, CacheValue>>;
+
+    /**
+     * @brief 构造函数
+     * @param capacity 缓存容量，默认为64，0表示无限制容量
+     * @param overflow 溢出容量，默认为8，允许缓存临时超出设定容量
+     *                 仅当缓存大小 >= 容量+溢出容量时才触发淘汰机制
+     */
+    explicit LruCache(size_type capacity = 64, size_type overflow = 8)
+    : m_capacity(capacity), m_overflow(overflow) {}
+
+    ~LruCache() {
+        UniqueGuard lock(m_mutex);
+        m_cache.clear();
+        m_lru_list.clear();
+    }
+
+    /**
+     * @brief 插入键值对
+     * @param key 键
+     * @param value 值
+     */
+    void insert(const key_type& key, const value_type& value) {
+        UniqueGuard lock(m_mutex);
+        _batch_update_dirty_nodes();
+        auto it = m_cache.find(key);
+        if (it != m_cache.end()) {
+            it->second.second.first = value;
+            it->second.second.second.store(false, std::memory_order_relaxed);
+            m_lru_list.splice(m_lru_list.begin(), m_lru_list, it->second.first);
+        } else {
+            m_lru_list.emplace_front(key);
+            m_cache.emplace(key, std::make_pair(m_lru_list.begin(),
+                                                std::make_pair(value, false)  // 初始脏标记为false
+                                                ));
+            _prune_if_needed();
+        }
+    }
+
+    /**
+     * @brief 插入键值对（移动版本）
+     * @param key 键
+     * @param value 值（右值引用）
+     */
+    void insert(const key_type& key, value_type&& value) {
+        UniqueGuard lock(m_mutex);
+        _batch_update_dirty_nodes();
+        auto it = m_cache.find(key);
+        if (it != m_cache.end()) {
+            it->second.second.first = std::move(value);
+            it->second.second.second.store(false, std::memory_order_relaxed);
+            m_lru_list.splice(m_lru_list.begin(), m_lru_list, it->second.first);
+        } else {
+            m_lru_list.emplace_front(key);
+            m_cache.emplace(
+              key, std::make_pair(m_lru_list.begin(), std::make_pair(std::move(value), false)));
+            _prune_if_needed();
+        }
+    }
+
+    /**
+     * @brief 获取键对应的值
+     * @param key 键
+     * @return 存在则返回值，否则返回ValueType的默认构造值
+     */
+    value_type get(const key_type& key) {
+        SharedGuard lock(m_mutex);
+        auto it = m_cache.find(key);
+        if (it != m_cache.end()) {
+            it->second.second.second.store(true, std::memory_order_relaxed);
+            return it->second.second.first;
+        }
+        return value_type{};
+    }
+
+    /**
+     * @brief 尝试获取键对应的值
+     * @param key 键
+     * @param value 用于接收值的引用参数
+     * @return 如果键存在返回true，否则返回false
+     */
+    bool tryGet(const key_type& key, value_type& value) {
+        SharedGuard lock(m_mutex);
+        auto it = m_cache.find(key);
+        if (it != m_cache.end()) {
+            it->second.second.second.store(true, std::memory_order_relaxed);
+            value = it->second.second.first;
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @brief 检查是否包含指定键
+     * @param key 键
+     * @return 存在返回true，否则返回false
+     */
+    bool contains(const key_type& key) {
+        SharedGuard lock(m_mutex);
+        return m_cache.find(key) != m_cache.end();
+    }
+
+    /**
+     * @brief 删除指定键
+     * @param key 要删除的键
+     * @return 成功删除返回true，不存在返回false
+     */
+    bool remove(const key_type& key) {
+        UniqueGuard lock(m_mutex);
+        auto it = m_cache.find(key);
+        if (it != m_cache.end()) {
+            m_lru_list.erase(it->second.first);
+            m_cache.erase(it);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @brief 清空缓存
+     */
+    void clear() {
+        UniqueGuard lock(m_mutex);
+        m_cache.clear();
+        m_lru_list.clear();
+    }
+
+    /**
+     * @brief 获取缓存当前大小
+     * @return 当前缓存元素数量
+     */
+    size_type size() const {
+        SharedGuard lock(m_mutex);
+        return m_cache.size();
+    }
+
+    /**
+     * @brief 检查缓存是否为空
+     * @return 空返回true，否则返回false
+     */
+    bool empty() const {
+        SharedGuard lock(m_mutex);
+        return m_cache.empty();
+    }
+
+    /**
+     * @brief 获取缓存容量
+     * @return 缓存容量
+     */
+    size_type capacity() const {
+        SharedGuard lock(m_mutex);
+        return m_capacity;
+    }
+
+    /**
+     * @brief 获取缓存溢出容量
+     * @return 缓存溢出容量
+     */
+    size_type overflow() const {
+        SharedGuard lock(m_mutex);
+        return m_overflow;
+    }
+
+    /**
+     * @brief 设置缓存容量
+     * @param capacity 新的容量，0表示不限制容量
+     */
+    void resize(size_type capacity) {
+        UniqueGuard lock(m_mutex);
+        m_capacity = capacity;
+        _prune_if_needed();
+    }
+
+    /**
+     * @brief 设置缓存溢出容量
+     * @param overflow 新的溢出容量
+     */
+    void setOverflow(size_type overflow) {
+        UniqueGuard lock(m_mutex);
+        m_overflow = overflow;
+        _prune_if_needed();
+    }
+
+private:
+    // 如果缓存已满，移除最久未使用的项
+    size_t _prune_if_needed() {
+        size_t maxAllowed = m_capacity + m_overflow;
+        if (m_capacity == 0 || m_cache.size() <= maxAllowed) {
+            return 0;
+        }
+        size_t count = 0;
+        while (m_cache.size() > m_capacity) {
+            m_cache.erase(m_lru_list.back());
+            m_lru_list.pop_back();
+            ++count;
+        }
+        return count;
+    }
+
+    // 批量更新所有脏节点：移到链表头部，清除脏标记
+    void _batch_update_dirty_nodes() {
+        // 修复点1：避免默认构造，改用指针/引用追踪最新脏节点
+        typename LruList::reverse_iterator latest_dirty_it;
+        bool has_dirty = false;
+
+        // 反向遍历链表：从尾部→头部，找第一个脏节点（最新访问的节点）
+        for (auto it = m_lru_list.rbegin(); it != m_lru_list.rend(); ++it) {
+            const key_type& key = *it;
+            auto cache_it = m_cache.find(key);
+            if (cache_it == m_cache.end()) {
+                continue;
+            }
+
+            auto& dirty_flag = cache_it->second.second.second;
+            // 修复点2：原子加载判断，避免未初始化访问
+            if (dirty_flag.load(std::memory_order_relaxed)) {
+                latest_dirty_it = it;
+                has_dirty = true;
+                break;  // 仅处理最新访问的脏节点，保留1在尾部
+            }
+        }
+
+        // 仅移动最新访问的脏节点到头部（修复点3：反向迭代器转正向迭代器）
+        if (has_dirty) {
+            // C++17：反向迭代器转正向迭代器（base()方法）
+            auto forward_it = latest_dirty_it.base();
+            --forward_it;  // 反向迭代器base()返回的是下一个正向迭代器，需减1
+
+            const key_type& key = *forward_it;
+            auto cache_it = m_cache.find(key);
+            if (cache_it != m_cache.end()) {
+                // 清除脏标记
+                cache_it->second.second.second.store(false, std::memory_order_relaxed);
+                // 移动节点到链表头部（splice仅支持正向迭代器）
+                m_lru_list.splice(m_lru_list.begin(), m_lru_list, forward_it);
+            }
+        }
+    }
+
+private:
+    size_type m_capacity;
+    size_type m_overflow;
+    LruList m_lru_list;
+    CacheMap m_cache;
+    mutable lock_type m_mutex;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/utilities/arithmetic.h

@@ -209,12 +209,12 @@ extern template float HKU_UTILS_API roundDown(float number, int ndigits);
 #endif
 
 /** 转小写字符串 */
-inline void to_lower(std::string &s) {
+inline void to_lower(std::string &s) noexcept {
     std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
 }
 
 /** 转大写字符串 */
-inline void to_upper(std::string &s) {
+inline void to_upper(std::string &s) noexcept {
     std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::toupper(c); });
 }
 

hikyuu/include/hikyuu/utilities/omp_macro.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2026 hikyuu.org
+ *
+ *  Created on: 2026-01-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/config.h"
+
+#if defined(_OPENMP)
+#include <omp.h>
+#define HKU_OMP_PARALLEL_FOR _Pragma("omp parallel for")
+#define HKU_OMP_SAFETY_PARALLEL_FOR \
+    _Pragma("omp parallel for num_threads(omp_get_max_threads()) if (!omp_in_parallel())")
+#define HKU_OMP_CHECK_THRESHOLD(guard, threshold)      \
+    if ((guard) > (threshold) && !omp_in_parallel()) { \
+        omp_set_num_threads(omp_get_max_threads());    \
+    }
+#else
+#define HKU_OMP_PARALLEL_FOR
+#define HKU_OMP_SAFETY_PARALLEL_FOR
+#define HKU_OMP_CHECK_THRESHOLD(guard, threshold)
+#endif

hikyuu/include/hikyuu/utilities/plugin/PluginManager.h

@@ -37,6 +37,11 @@ public:
         m_plugin_path = plugin_path;
     }
 
+    void clear() noexcept {
+        std::unique_lock<std::shared_mutex> write_lock(m_mutex);
+        m_plugins.clear();
+    }
+
     template <typename PluginInterfaceT>
     PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept {
         PluginInterfaceT* ret{nullptr};

hikyuu/include/hikyuu/utilities/thread/GlobalStealThreadPool.h

@@ -8,8 +8,6 @@
  */
 
 #pragma once
-#ifndef HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H
-#define HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H
 
 #include <future>
 #include <thread>
@@ -65,7 +63,7 @@ public:
                 m_threads.emplace_back(&GlobalStealThreadPool::worker_thread, this, i);
             }
         } catch (...) {
-            m_done = true;
+            m_done.store(true, std::memory_order_release);
             throw;
         }
     }
@@ -74,7 +72,7 @@ public:
      * 析构函数，等待并阻塞至线程池内所有任务完成
      */
     ~GlobalStealThreadPool() {
-        if (!m_done) {
+        if (!m_done.load(std::memory_order_acquire)) {
             join();
         }
     }
@@ -86,7 +84,7 @@ public:
 
     /** 剩余任务数 */
     size_t remain_task_count() const {
-        if (m_done) {
+        if (m_done.load(std::memory_order_acquire)) {
             return 0;
         }
         size_t total = m_master_work_queue.size();
@@ -108,7 +106,7 @@ public:
     /** 向线程池提交任务 */
     template <typename FunctionType>
     auto submit(FunctionType f) {
-        if (m_thread_need_stop.isSet() || m_done) {
+        if (m_thread_need_stop.isSet() || m_done.load(std::memory_order_acquire)) {
             throw std::logic_error(
               "You can't submit a task to the stopped GlobalStealThreadPool!!");
         }
@@ -116,13 +114,16 @@ public:
         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 (m_local_work_queue) {
+
+        std::thread::id id = std::this_thread::get_id();
+        if (m_local_work_queue && id == m_thread_id) {
             // 本地线程任务从前部入队列（递归成栈）
             m_local_work_queue->push_front(std::move(task));
         } else {
             m_master_work_queue.push(std::move(task));
             m_cv.notify_one();
         }
+
         return res;
     }
 
@@ -132,19 +133,17 @@ public:
 
     /** 返回线程池结束状态 */
     bool done() const {
-        return m_done;
+        return m_done.load(std::memory_order_acquire);
     }
 
     /**
      * 等待各线程完成当前执行的任务后立即结束退出
      */
     void stop() {
-        if (m_done) {
+        if (m_done.exchange(true, std::memory_order_acq_rel)) {
             return;
         }
 
-        m_done = true;
-
         // 同时加入结束任务指示，以便在dll退出时也能够终止
         for (size_t i = 0; i < m_worker_num; i++) {
             if (m_interrupt_flags[i]) {
@@ -164,6 +163,7 @@ public:
         for (size_t i = 0; i < m_worker_num; i++) {
             m_queues[i]->clear();
         }
+        m_threads.clear();
     }
 
     /**
@@ -171,7 +171,7 @@ public:
      * @note 至此线程池能工作线程结束不可再使用
      */
     void join() {
-        if (m_done) {
+        if (m_done.load(std::memory_order_acquire)) {
             return;
         }
 
@@ -196,7 +196,7 @@ public:
                 }
             }
 
-            m_done = true;
+            m_done.store(true, std::memory_order_release);
             for (size_t i = 0; i < m_worker_num; i++) {
                 if (m_interrupt_flags[i]) {
                     m_interrupt_flags[i]->set();
@@ -218,11 +218,46 @@ public:
             }
         }
 
-        m_done = true;
+        m_done.store(true, std::memory_order_release);
         m_master_work_queue.clear();
         for (size_t i = 0; i < m_worker_num; i++) {
             m_queues[i]->clear();
         }
+        m_threads.clear();
+    }
+
+public:
+    bool run_available_task_once() {
+        bool task_run = true;
+        task_type task;
+        if (m_local_work_queue) {
+            if (pop_task_from_local_queue(task)) {
+                if (!task.isNullTask()) {
+                    task();
+                } else {
+                    m_thread_need_stop.set();
+                }
+            } else if (pop_task_from_master_queue(task)) {
+                if (!task.isNullTask()) {
+                    task();
+                } else {
+                    m_thread_need_stop.set();
+                }
+            } else if (pop_task_from_other_thread_queue(task)) {
+                if (!task.isNullTask()) {
+                    task();
+                }
+            } else {
+                task_run = false;
+            }
+        } else if (pop_task_from_master_queue(task)) {
+            if (!task.isNullTask()) {
+                task();
+            }
+        } else {
+            task_run = false;
+        }
+        return task_run;
     }
 
 private:
@@ -243,17 +278,20 @@ private:
     inline static thread_local WorkStealQueue* m_local_work_queue = nullptr;  // 本地任务队列
     inline static thread_local int m_index = -1;                              // 在线程池中的序号
     inline static thread_local InterruptFlag m_thread_need_stop;              // 线程停止运行指示
+    inline static thread_local std::thread::id m_thread_id;
 #else
     static thread_local WorkStealQueue* m_local_work_queue;  // 本地任务队列
     static thread_local int m_index;                         // 在线程池中的序号
     static thread_local InterruptFlag m_thread_need_stop;    // 线程停止运行指示
+    static thread_local std::thread::id m_thread_id;
 #endif
 
     void worker_thread(int index) {
+        m_thread_id = std::this_thread::get_id();
         m_interrupt_flags[index] = &m_thread_need_stop;
         m_index = index;
         m_local_work_queue = m_queues[index].get();
-        while (!m_thread_need_stop.isSet() && !m_done) {
+        while (!m_thread_need_stop.isSet() && !m_done.load(std::memory_order_acquire)) {
             run_pending_task();
         }
         m_local_work_queue = nullptr;
@@ -277,10 +315,18 @@ private:
                 m_thread_need_stop.set();
             }
         } else if (pop_task_from_other_thread_queue(task)) {
-            task();
+            if (!task.isNullTask()) {
+                task();
+            }
         } else {
+            // std::this_thread::yield();
             std::unique_lock<std::mutex> lk(m_cv_mutex);
-            m_cv.wait(lk, [this] { return this->m_done || !this->m_master_work_queue.empty(); });
+            m_cv.wait_for(lk, std::chrono::microseconds(10), [this] {
+                return this->m_done.load(std::memory_order_acquire) ||
+                       !this->m_master_work_queue.empty() ||
+                       (m_local_work_queue && !m_local_work_queue->empty()) ||
+                       has_other_remain_task();
+            });
         }
     }
 
@@ -302,8 +348,15 @@ private:
         }
         return false;
     }
+
+    bool has_other_remain_task() {
+        for (int i = 0; i < m_worker_num; ++i) {
+            if (i != m_index && m_queues[i] && !m_queues[i]->empty()) {
+                return true;
+            }
+        }
+        return false;
+    }
 };
 
 } /* namespace hku */
-
-#endif /* HIKYUU_UTILITIES_THREAD_STEALTHREADPOOL_H */

hikyuu/include/hikyuu/utilities/thread/GlobalThreadPool.h

@@ -8,8 +8,6 @@
  */
 
 #pragma once
-#ifndef HIKYUU_UTILITIES_THREAD_THREADPOOL_H
-#define HIKYUU_UTILITIES_THREAD_THREADPOOL_H
 
 #include <cstdio>
 #include <future>
@@ -220,5 +218,3 @@ private:
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
-
-#endif /* HIKYUU_UTILITIES_THREAD_THREADPOOL_H */

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

@@ -8,8 +8,6 @@
  */
 
 #pragma once
-#ifndef HIKYUU_UTILITIES_THREAD_THREADPOOL_H
-#define HIKYUU_UTILITIES_THREAD_THREADPOOL_H
 
 #include <cstdio>
 #include <future>
@@ -200,5 +198,3 @@ private:
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
-
-#endif /* HIKYUU_UTILITIES_THREAD_THREADPOOL_H */