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

hikyuu/include/hikyuu/trade_sys/slippage/SlippageBase.h

@@ -71,7 +71,6 @@ public:
     /** 子类计算接口，由setTO调用 */
     virtual void _calculate() = 0;
 
-protected:
     virtual bool isPythonObject() const {
         return false;
     }

hikyuu/include/hikyuu/trade_sys/stoploss/StoplossBase.h

@@ -86,7 +86,6 @@ public:
     /** 子类计算接口，由setTO调用 */
     virtual void _calculate() = 0;
 
-protected:
     virtual bool isPythonObject() const {
         return false;
     }

hikyuu/include/hikyuu/trade_sys/system/System.h

@@ -36,7 +36,7 @@ class HKU_API WalkForwardSystem;
  * 交易系统基类
  * @ingroup System
  */
-class HKU_API System {
+class HKU_API System : public enable_shared_from_this<System> {
     PARAMETER_SUPPORT_WITH_CHECK
     friend class HKU_API Portfolio;
     friend class HKU_API AllocateFundsBase;
@@ -276,7 +276,6 @@ public:
     // 处理延迟买入请求，仅供 PF 调用
     virtual TradeRecord pfProcessDelayBuyRequest(const Datetime& date);
 
-protected:
     virtual bool isPythonObject() const {
         return false;
     }

hikyuu/include/hikyuu/utilities/Log.h

@@ -343,13 +343,12 @@ std::shared_ptr<spdlog::logger> HKU_UTILS_API getHikyuuLogger();
     }
 
 /** 用于 catch (...) 中打印，减少编译后代码大小 */
-extern std::string g_unknown_error_msg;
-#define HKU_THROW_UNKNOWN HKU_THROW("{}", g_unknown_error_msg);
-#define HKU_TRACE_UNKNOWN HKU_TRACE("{}", g_unknown_error_msg)
-#define HKU_DEBUG_UNKNOWN HKU_DEBUG("{}", g_unknown_error_msg)
-#define HKU_INFO_UNKNOWN HKU_INFO("{}", g_unknown_error_msg)
-#define HKU_ERROR_UNKNOWN HKU_ERROR("{}", g_unknown_error_msg)
-#define HKU_FATAL_UNKNOWN HKU_FATAL("{}", g_unknown_error_msg)
+#define HKU_THROW_UNKNOWN HKU_THROW("Unknown error!")
+#define HKU_TRACE_UNKNOWN HKU_TRACE("Unknown error!")
+#define HKU_DEBUG_UNKNOWN HKU_DEBUG("Unknown error!")
+#define HKU_INFO_UNKNOWN HKU_INFO("Unknown error!");
+#define HKU_ERROR_UNKNOWN HKU_ERROR("Unknown error!");
+#define HKU_FATAL_UNKNOWN HKU_FATAL("Unknown error!");
 
 #if CPP_STANDARD >= CPP_STANDARD_20
 #define CLASS_LOGGER_IMP(cls) \

hikyuu/include/hikyuu/utilities/Parameter.h

@@ -503,6 +503,23 @@ inline void Parameter::set(const string& name, const boost::any& value) {
     m_params[name] = value;
 }
 
+template <>
+inline int64_t Parameter::get(const string& name) const {
+    param_map_t::const_iterator iter;
+    iter = m_params.find(name);
+    if (iter == m_params.end()) {
+        throw std::out_of_range("out_of_range in Parameter::get : " + name);
+    }
+    try {
+        if (iter->second.type() == typeid(int)) {
+            return boost::any_cast<int>(iter->second);
+        }
+        return boost::any_cast<int64_t>(iter->second);
+    } catch (...) {
+        throw std::runtime_error("failed conversion param: " + name);
+    }
+}
+
 HKU_API bool operator==(const Parameter&, const Parameter&);
 HKU_API bool operator!=(const Parameter&, const Parameter&);
 HKU_API bool operator<(const Parameter&, const Parameter&);

hikyuu/include/hikyuu/utilities/config.h

@@ -6,33 +6,61 @@
 
 // clang-format off
 
+#ifndef HKU_ENABLE_MYSQL
 #define HKU_ENABLE_MYSQL 1
 #if HKU_ENABLE_MYSQL && HKU_OS_WINDOWS
 #ifndef NOMINMAX
 #define NOMINMAX
 #endif
 #endif
+#endif
 
+#ifndef HKU_ENABLE_SQLITE
 #define HKU_ENABLE_SQLITE 1
+#endif
+#ifndef HKU_ENABLE_SQLCIPHER
 #define HKU_ENABLE_SQLCIPHER 0
+#endif
+#ifndef HKU_SQL_TRACE
 /* #define HKU_SQL_TRACE 0 */
+#endif
 
+#ifndef HKU_SUPPORT_DATETIME
 #define HKU_SUPPORT_DATETIME 1
+#endif
 
+#ifndef HKU_ENABLE_INI_PARSER
 #define HKU_ENABLE_INI_PARSER 1
+#endif
 
+#ifndef HKU_ENABLE_STACK_TRACE
 #define HKU_ENABLE_STACK_TRACE 0
+#endif
 
+#ifndef HKU_CLOSE_SPEND_TIME
 #define HKU_CLOSE_SPEND_TIME 0
+#endif
 
+#ifndef HKU_USE_SPDLOG_ASYNC_LOGGER
 #define HKU_USE_SPDLOG_ASYNC_LOGGER 0
+#endif
+#ifndef HKU_LOG_ACTIVE_LEVEL
 #define HKU_LOG_ACTIVE_LEVEL 2
+#endif
 
+#ifndef HKU_ENABLE_HTTP_CLIENT
 #define HKU_ENABLE_HTTP_CLIENT 1
+#endif
+#ifndef HKU_ENABLE_HTTP_CLIENT_SSL
 #define HKU_ENABLE_HTTP_CLIENT_SSL 0
+#endif
+#ifndef HKU_ENABLE_HTTP_CLIENT_ZIP
 #define HKU_ENABLE_HTTP_CLIENT_ZIP 0
+#endif
 
+#ifndef HKU_ENABLE_NODE
 #define HKU_ENABLE_NODE 1
+#endif
 
 // clang-format on
 

hikyuu/include/hikyuu/utilities/plugin/PluginBase.h

@@ -12,6 +12,7 @@
 #include <string>
 #include "hikyuu/utilities/config.h"
 #include "hikyuu/utilities/osdef.h"
+#include "hikyuu/utilities/Log.h"
 
 namespace hku {
 
@@ -35,12 +36,26 @@ public:
 #if HKU_OS_WINDOWS
 #define HKU_PLUGIN_DEFINE(plugin)                                      \
     extern "C" __declspec(dllexport) hku::PluginBase* createPlugin() { \
-        return new plugin();                                           \
+        try {                                                          \
+            return new plugin();                                       \
+        } catch (const std::exception& e) {                            \
+            HKU_ERROR("{}", e.what());                                 \
+            return nullptr;                                            \
+        } catch (...) {                                                \
+            return nullptr;                                            \
+        }                                                              \
     }
 #else
 #define HKU_PLUGIN_DEFINE(plugin)                \
     extern "C" hku::PluginBase* createPlugin() { \
-        return new plugin();                     \
+        try {                                    \
+            return new plugin();                 \
+        } catch (const std::exception& e) {      \
+            HKU_ERROR("{}", e.what());           \
+            return nullptr;                      \
+        } catch (...) {                          \
+            return nullptr;                      \
+        }                                        \
     }
 #endif
 

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

@@ -10,7 +10,7 @@
 #include <string>
 #include <memory>
 #include <unordered_map>
-#include <mutex>
+#include <shared_mutex>
 #include "hikyuu/utilities/Log.h"
 #include "hikyuu/utilities/plugin/PluginLoader.h"
 
@@ -38,35 +38,54 @@ public:
     }
 
     template <typename PluginInterfaceT>
-    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept;
+    PluginInterfaceT* getPlugin(const std::string& pluginname) noexcept {
+        PluginInterfaceT* ret{nullptr};
+        try {
+            {
+                std::shared_lock<std::shared_mutex> read_lock(m_mutex);
+                auto it = m_plugins.find(pluginname);
+                if (it != m_plugins.end()) {
+                    ret = it->second->instance<PluginInterfaceT>();
+                    return ret;
+                }
+            }
 
-private:
-    std::unordered_map<std::string, std::unique_ptr<PluginLoader>>::iterator load(
-      const std::string& pluginname) noexcept {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
-        if (loader->load(pluginname)) {
-            auto [it, success] = m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
-            if (success) {
-                return it;
+            std::unique_ptr<PluginLoader> loader = std::make_unique<PluginLoader>(m_plugin_path);
+            if (!loader->load(pluginname)) {
+                HKU_DEBUG("Load plugin {} failed: {}", pluginname, loader->getFileName(pluginname));
+                return ret;
+            }
+
+            {
+                std::unique_lock<std::shared_mutex> write_lock(m_mutex);
+                auto it = m_plugins.find(pluginname);
+                if (it != m_plugins.end()) {
+                    // 复用已插入的插件实例
+                    ret = it->second->instance<PluginInterfaceT>();
+                } else {
+                    // 插入新加载的插件
+                    auto [it, success] =
+                      m_plugins.insert(std::make_pair(pluginname, std::move(loader)));
+                    if (success) {
+                        ret = it->second->instance<PluginInterfaceT>();
+                    }
+                }
+                return ret;
             }
+        } catch (const std::exception& e) {
+            HKU_ERROR("Load plugin {} failed: {}", pluginname, e.what());
+            ret = nullptr;
+        } catch (...) {
+            HKU_ERROR("Load plugin {} failed: unknown exception", pluginname);
+            ret = nullptr;
         }
-        return m_plugins.end();
+        return ret;
     }
 
 private:
     std::string m_plugin_path;
     std::unordered_map<std::string, std::unique_ptr<PluginLoader>> m_plugins;
-    std::mutex m_mutex;
+    std::shared_mutex m_mutex;
 };
 
-template <typename PluginInterfaceT>
-PluginInterfaceT* PluginManager::getPlugin(const std::string& pluginname) noexcept {
-    auto it = m_plugins.find(pluginname);
-    if (it == m_plugins.end()) {
-        it = load(pluginname);
-    }
-    return it != m_plugins.end() ? it->second->instance<PluginInterfaceT>() : nullptr;
-}
-
 }  // namespace hku

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

@@ -218,12 +218,11 @@ public:
             }
         }
 
+        m_done = true;
         m_master_work_queue.clear();
         for (size_t i = 0; i < m_worker_num; i++) {
             m_queues[i]->clear();
         }
-
-        m_done = true;
     }
 
 private:

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

@@ -174,8 +174,8 @@ public:
             }
         }
 
-        m_master_work_queue.clear();
         m_done = true;
+        m_master_work_queue.clear();
     }
 
 private:

hikyuu/include/hikyuu/utilities/thread/MQStealThreadPool.h

@@ -0,0 +1,286 @@
+/*
+ * StealMQStealThreadPool.h
+ *
+ *  Copyright (c) 2019 hikyuu.org
+ *
+ *  Created on: 2019-9-16
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <future>
+#include <thread>
+#include <chrono>
+#include <vector>
+#include "FuncWrapper.h"
+#include "MQStealQueue.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 无集中队列多队列偷取任务池
+ * @ingroup ThreadPool
+ */
+#ifdef _MSC_VER
+class MQStealThreadPool {
+#else
+class HKU_UTILS_API MQStealThreadPool {
+#endif
+public:
+    /**
+     * 默认构造函数，创建和当前系统CPU数一致的线程数
+     */
+    MQStealThreadPool() : MQStealThreadPool(std::thread::hardware_concurrency()) {}
+
+    /**
+     * 构造函数，创建指定数量的线程
+     * @param n 指定的线程数
+     * @param until_empty 任务队列为空时，自动停止运行
+     */
+    explicit MQStealThreadPool(size_t n, bool until_empty = true)
+    : m_done(false), m_worker_num(n), m_runnging_until_empty(until_empty) {
+        try {
+            m_interrupt_flags.resize(m_worker_num);
+            for (size_t i = 0; i < m_worker_num; i++) {
+                // 创建工作线程及其任务队列
+                m_queues.emplace_back(new MQStealQueue<task_type>);
+            }
+            // 初始完毕所有线程资源后再启动线程
+            for (int i = 0; i < m_worker_num; i++) {
+                m_threads.emplace_back(&MQStealThreadPool::worker_thread, this, i);
+                m_thread_index[m_threads.back().get_id()] = i;
+            }
+        } catch (...) {
+            m_done = true;
+            throw;
+        }
+    }
+
+    /**
+     * 析构函数，等待并阻塞至线程池内所有任务完成
+     */
+    ~MQStealThreadPool() {
+        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 = 0;
+        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 MQStealThreadPool!");
+        }
+
+        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));
+            return res;
+        }
+
+        m_queues[m_current_index]->push(std::move(task));
+        m_current_index++;
+        if (m_current_index >= m_worker_num) {
+            m_current_index = 0;
+        }
+        return res;
+    }
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    /** 返回线程池结束状态 */
+    bool done() const {
+        return m_done;
+    }
+
+    /**
+     * 等待各线程完成当前执行的任务后立即结束退出
+     */
+    void stop() {
+        if (m_done) {
+            return;
+        }
+
+        // 同时加入结束任务指示，以便在dll退出时也能够终止
+        for (size_t i = 0; i < m_worker_num; i++) {
+            if (m_interrupt_flags[i]) {
+                m_interrupt_flags[i].set();
+            }
+            m_queues[i]->push(FuncWrapper());
+        }
+
+        for (size_t i = 0; i < m_worker_num; i++) {
+            if (m_threads[i].joinable()) {
+                m_threads[i].join();
+            }
+        }
+
+        m_done = true;
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_queues[i]->clear();
+        }
+    }
+
+    /**
+     * 等待并阻塞至线程池内所有任务完成
+     * @note 至此线程池能工作线程结束不可再使用
+     */
+    void join() {
+        if (m_done) {
+            return;
+        }
+
+        // 指示各工作线程在未获取到工作任务时，停止运行
+        if (m_runnging_until_empty) {
+            while (true) {
+                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;
+                }
+
+                std::this_thread::yield();
+            }
+
+            m_done = true;
+            for (size_t i = 0; i < m_worker_num; i++) {
+                if (m_interrupt_flags[i]) {
+                    m_interrupt_flags[i].set();
+                }
+            }
+        }
+
+        for (size_t i = 0; i < m_worker_num; i++) {
+            m_queues[i]->push(FuncWrapper());
+        }
+
+        // 等待线程结束
+        for (size_t i = 0; i < m_worker_num; i++) {
+            if (m_threads[i].joinable()) {
+                m_threads[i].join();
+            }
+        }
+
+        m_done = true;
+        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_runnging_until_empty;  // 运行直到队列空时停止
+
+    std::vector<std::unique_ptr<MQStealQueue<task_type>>> m_queues;  // 线程任务队列
+    std::vector<InterruptFlag> m_interrupt_flags;                    // 线程终止标志
+    std::vector<std::thread> m_threads;                              // 工作线程
+
+    std::unordered_map<std::thread::id, int> m_thread_index;
+    int m_current_index = 0;  // 当前放置新任务时的队列索引
+
+    void worker_thread(int index) {
+        while (!m_interrupt_flags[index].isSet() && !m_done) {
+            run_pending_task(index);
+        }
+    }
+
+    void run_pending_task(int index) {
+        task_type task;
+        // 尝试从本地队列获取任务并执行
+        if (m_queues[index]->try_pop(task)) {
+            if (task.isNullTask()) {
+                m_interrupt_flags[index].set();
+            } else {
+                task();
+            }
+        } else if (pop_task_from_other_thread_queue(task, index)) {
+            task();
+        } else {
+            // 阻塞并等待本地队列中有新的任务
+            // 注：如果是递归情况，任务被优先加入本地队列且彼此依赖，如果任务被其他线程偷取到的话，将导致其他线程被阻塞并等待
+            // 所以，此处等待本地队列而不是继续循环偷取
+            m_queues[index]->wait_and_pop(task);
+            if (task.isNullTask()) {
+                m_interrupt_flags[index].set();
+            } else {
+                task();
+            }
+        }
+    }
+
+    bool pop_task_from_other_thread_queue(task_type& task, int index) {
+        for (size_t i = 0; i < m_worker_num; ++i) {
+            size_t pos = (index + i + 1) % m_worker_num;
+            if (pos != index && m_queues[pos]->try_steal(task)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};  // namespace hku
+
+} /* namespace hku */
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

hikyuu/include/hikyuu/utilities/thread/MQThreadPool.h

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