feat(context): 增加预加载数量参数

Author: fasiondog

hikyuu/__init__.py

@@ -208,6 +208,7 @@ def load_hikyuu(**kwargs):
     options = {
         "stock_list": ["sh000001"],
         "ktype_list": ["day"],
+        "preload_num: {"day_max": 100000}
         "load_history_finance": False,
         "load_weight": False,
         "start_spot": False,
@@ -223,6 +224,7 @@ def load_hikyuu(**kwargs):
                     支持的K线类型有:
                     'day', 'week', 'month', 'quarter', 'halfyear', 'year', 'min', 'min5',
                     'min15', 'min30', 'min60', 'hour2'
+        preload_num (dict): {'day_max': 100000, 'week_max': 100000, 'month_max': 100000, ...}
         load_history_finance (boolean): 预加载历史财务数至内存，默认为 True
         load_weight (boolean): 加载权息数据，默认为 True
 
@@ -295,8 +297,10 @@ def load_hikyuu(**kwargs):
     # 优先使用传入参数作为加载上下文
     if 'stock_list' in kwargs:
         context.stock_list = kwargs['stock_list']
-    if 'ktype_list' in os.environ:
+    if 'ktype_list' in kwargs:
         context.ktype_list = kwargs['ktype_list']
+    if 'preload_num' in kwargs:
+        context.preload_num = kwargs['preload_num']
     if 'load_history_finance' in kwargs:
         hku_param.set("load_history_finance", kwargs['load_history_finance'])
     if 'load_weight' in kwargs:

hikyuu_cpp/hikyuu/StockManager.cpp

@@ -127,28 +127,35 @@ void StockManager::loadData() {
 
 void StockManager::loadAllKData() {
     // 按 K 线类型控制加载顺序
-    vector<KQuery::KType> default_ktypes{
-      KQuery::DAY,   KQuery::MIN,   KQuery::WEEK,  KQuery::MONTH, KQuery::QUARTER, KQuery::HALFYEAR,
-      KQuery::YEAR,  KQuery::MIN5,  KQuery::MIN15, KQuery::MIN30, KQuery::MIN60,   KQuery::MIN3,
-      KQuery::HOUR2, KQuery::HOUR4, KQuery::HOUR6, KQuery::HOUR12};
-
     vector<KQuery::KType> ktypes;
     vector<string> low_ktypes;
 
     // 如果上下文指定了 ktype list，则按上下文指定的 ktype 顺序加载，否则按默认顺序加载
     const auto& context_ktypes = m_context.getKTypeList();
     if (context_ktypes.empty()) {
-        ktypes = std::move(default_ktypes);
-        HKU_ASSERT(ktypes.size() == KQuery::getAllKType().size());
+        ktypes = KQuery::getAllKType();
 
     } else {
+        // 使用上下文预加载参数覆盖全局预加载参数
         ktypes = context_ktypes;
+        for (const auto& ktype : ktypes) {
+            m_preloadParam.set<bool>(ktype, true);
+        }
     }
 
+    const auto& context_preload_num = m_context.getPreloadNum();
     low_ktypes.reserve(ktypes.size());
     for (const auto& ktype : ktypes) {
         auto& back = low_ktypes.emplace_back(ktype);
         to_lower(back);
+
+        // 判断上下文是否指定了预加载数量，如果指定了，则覆盖默认值
+        string preload_key = fmt::format("{}_max", back);
+        auto context_iter = context_preload_num.find(preload_key);
+        if (context_iter != context_preload_num.end()) {
+            m_preloadParam.set<int>(preload_key, context_iter->second);
+        }
+
         HKU_INFO_IF(m_preloadParam.tryGet<bool>(back, false), "Preloading all {} kdata to buffer !",
                     back);
     }

hikyuu_cpp/hikyuu/StrategyContext.cpp

@@ -49,9 +49,25 @@ StrategyContext::StrategyContext(const vector<string>& stockCodeList) {
 }
 
 StrategyContext::StrategyContext(const vector<string>& stockCodeList,
-                                 const vector<KQuery::KType>& ktypeList) {
+                                 const vector<KQuery::KType>& ktypeList,
+                                 const unordered_map<string, int>& preloadNum) {
     _removeDuplicateCode(stockCodeList);
     _checkAndRemoveDuplicateKType(ktypeList);
+    setPreloadNum(preloadNum);
+}
+
+void StrategyContext::setPreloadNum(const unordered_map<string, int>& preloadNum) {
+    m_preloadNum.clear();
+    m_preloadNum.reserve(preloadNum.size());
+    for (auto it = preloadNum.cbegin(); it != preloadNum.cend(); ++it) {
+        string key = it->first;
+        to_lower(key);
+        if (it->second > 0) {
+            m_preloadNum[key] = it->second;
+        } else {
+            HKU_WARN("Invalid preload number {}: {}", key, it->second);
+        }
+    }
 }
 
 void StrategyContext::_removeDuplicateCode(const vector<string>& stockCodeList) {

hikyuu_cpp/hikyuu/StrategyContext.h

@@ -24,19 +24,21 @@ class HKU_API StrategyContext {
 
     /**
      * 构造函数
-     * @note 未指定 ktypelist 时，默认按预加载参数加载全部
      * @param stockCodeList 指定的证券代码列表，如：如：{"sz000001", "sz000002"}
      */
     explicit StrategyContext(const vector<string>& stockCodeList);
 
     /**
      * 构造函数
      * @note 证券列表中如果包含 ("ALL") 则表示全部证券;
-     * 指定K线类型列表同时影响着K线数据的优先加载顺序，靠前的将优先加载。同时受系统配置中预加载参数影响！
+     *       1. 指定K线类型列表同时影响着K线数据的优先加载顺序，靠前的将优先加载。
+     *       2. 未指定 ktypelist 或 preloadNum 时，将使用全局配置文件参数
      * @param stockCodeList 指定的证券代码列表，如：{"sh000001", "sz000001"}
      * @param ktypeList 指定的 K线数据列表，如：{"day", "min"}
+     * @param preloadNum 指定的预加载数量，如：{{"min_max", 100}, {"day_max", 200}}
      */
-    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList);
+    StrategyContext(const vector<string>& stockCodeList, const vector<KQuery::KType>& ktypeList,
+                    const unordered_map<string, int>& preloadNum = {});
 
     // 自定义移动构造与赋值会引起 python 中无法正常退出
     // StrategyContext(const StrategyContext&) = default;
@@ -75,6 +77,12 @@ class HKU_API StrategyContext {
         return m_ktypeList;
     }
 
+    void setPreloadNum(const unordered_map<string, int>& preloadNum);
+
+    const unordered_map<string, int>& getPreloadNum() const noexcept {
+        return m_preloadNum;
+    }
+
     /**
      * 隐含的默认必须被加载的证券列表
      * @note 影响交易日历判断、和某些常被作为默认比较基准的证券，通常被作为某些函数的默认值
@@ -100,6 +108,7 @@ class HKU_API StrategyContext {
     vector<string> m_mustLoad{"sh000001", "sh000300"};  // 默认必须加载的 stock
     vector<string> m_stockCodeList;
     vector<KQuery::KType> m_ktypeList;
+    unordered_map<string, int> m_preloadNum;
 };
 
 HKU_API std::ostream& operator<<(std::ostream& os, const StrategyContext& context);

hikyuu_pywrap/_StrategyContext.cpp

@@ -15,8 +15,18 @@ void export_StrategeContext(py::module& m) {
     py::class_<StrategyContext>(m, "StrategyContext", "策略上下文")
       .def(py::init<>())
       .def(py::init<const vector<string>&>())
-      .def(py::init<const vector<string>&, const vector<KQuery::KType>&>(), py::arg("stock_list"),
-           py::arg("ktype_list"))
+      .def(py::init<const vector<string>&, const vector<KQuery::KType>&,
+                    const unordered_map<string, int>&>(),
+           py::arg("stock_list"), py::arg("ktype_list"),
+           py::arg("preload_num") = unordered_map<string, int>(),
+           R"(__init__(self, stock_list, ktype_list, [preload_num={}])
+        
+  创建策略上下文
+
+  :param stock_list: 需要加载的证券代码列表，如：["sz000001", "sz000002"], 如包含 'ALL', 表示加载全部
+  :param ktype_list: 需要加载的K线类型列表, 如：["day", "min"], 未指定时取全局配置文件中配置的默认值
+  :param preload_num: 预加载数量，默认为空，如：{"min_max": 100, "day_max": 200}. 未指定时取全局配置文件中配置的默认值
+  :return: 策略上下文对象)")
 
       .def("__str__", &StrategyContext::str)
       .def("__repr__", &StrategyContext::str)
@@ -29,6 +39,8 @@ void export_StrategeContext(py::module& m) {
         &StrategyContext::setStockCodeList, py::return_value_policy::copy, "股票代码列表")
       .def_property("ktype_list", py::overload_cast<>(&StrategyContext::getKTypeList, py::const_),
                     &StrategyContext::setKTypeList, py::return_value_policy::copy, "需要的K线类型")
+      .def_property("preload_num", py::overload_cast<>(&StrategyContext::getPreloadNum, py::const_),
+                    &StrategyContext::setPreloadNum, py::return_value_policy::copy, "预加载数量")
 
       .def("empty", &StrategyContext::empty, "上下文证券代码列表是否为空");
 }