Merge pull request #494 from woleigegg/fix/compiled-plan-review-followup-pr

fix(indicator): compiled factor plan review follow-ups (#493)

Author: fasiondog

hikyuu_cpp/hikyuu/factor/FactorSet.cpp

@@ -240,6 +240,11 @@ vector<IndicatorList> FactorSet::getValues(const StockList& stocks, const KQuery
                 return executor.executeValues(kdata);
             };
 
+            // 这里直接向全局线程池 submit 范围任务，且有外层调用者自身就在 work 线程里 submit
+            // 本函数时（嵌套调用）的可能。`wait_for_all_non_blocking` 必须支持在等待期间
+            // work-steal 已提交的子任务（否则当池被外层任务占满时会死锁：外层等待本任务、
+            // 本任务等待子任务、却没有空闲 worker 去执行子任务）。修改这一段前请确认
+            // `GlobalStealThreadPool` 的 non_blocking 等待确有 steal 语义。
             auto* task_group = get_global_task_group();
             HKU_ASSERT(task_group);
             auto ranges = parallelIndexRange(0, stk_total, task_group->worker_num());

hikyuu_cpp/hikyuu/factor/imp/CompiledFactorPlan.cpp

@@ -1,6 +1,9 @@
 /*
  *  Copyright (c) 2026 hikyuu.org
  *
+ *  Created on: 2026-07-15
+ *      Author: woleigegg
+ *
  *  Internal compiled execution plan for stock-local factor formulas.
  */
 

hikyuu_cpp/hikyuu/factor/imp/CompiledFactorPlan.h

@@ -1,6 +1,9 @@
 /*
  *  Copyright (c) 2026 hikyuu.org
  *
+ *  Created on: 2026-07-15
+ *      Author: woleigegg
+ *
  *  Internal compiled execution plan for stock-local factor formulas.
  */
 

hikyuu_cpp/hikyuu/indicator/IndicatorImp.cpp

@@ -927,6 +927,14 @@ Indicator IndicatorImp::calculate() {
                     _calculate(Indicator());
                 }
             } else {
+                // 动态周期叶子没有右子节点驱动 buffer 定长。当执行器跨股票重绑 context 时，
+                // 空输入会让 _dyn_calculate 在 total == 0 处提前返回而完全不触碰 buffer，
+                // 导致上一只股票的数据与长度残留在 buffer 中（脏缓冲区）。这里在调用前按
+                // 当前 context 长度预尺寸并 null 填充 buffer，使得即便 _dyn_calculate 什么都不写，
+                // size()/data() 也能返回正确（可能更短）的长度。
+                if (isNeedContext()) {
+                    _readyBuffer(getContext().size(), m_result_num);
+                }
                 _dyn_calculate(Indicator());
             }
             break;
@@ -1977,18 +1985,20 @@ bool IndicatorImp::alike(const IndicatorImp &other) const {
                     m_ind_params.size() != other.m_ind_params.size() || m_params != other.m_params,
                   false);
 
-    if (needSelfAlikeCompare()) {
-        HKU_IF_RETURN(!selfAlike(other), false);
-        HKU_IF_RETURN(isLeaf(), true);
-    }
-
     auto iter1 = m_ind_params.cbegin();
     auto iter2 = other.m_ind_params.cbegin();
     for (; iter1 != m_ind_params.cend() && iter2 != other.m_ind_params.cend(); ++iter1, ++iter2) {
         HKU_IF_RETURN(iter1->first != iter2->first, false);
         HKU_IF_RETURN(!iter1->second->alike(*(iter2->second)), false);
     }
 
+    if (needSelfAlikeCompare()) {
+        HKU_IF_RETURN(!selfAlike(other), false);
+        // Special leaves use structural identity so an unevaluated operator template (such as
+        // CVAL(value)) can match a calculated input without comparing runtime buffers.
+        HKU_IF_RETURN(isLeaf(), true);
+    }
+
     if (isLeaf() && other.isLeaf()) {
         HKU_IF_RETURN(this->size() != other.size(), false);
         auto const *d1 = this->data();

hikyuu_cpp/hikyuu/indicator/IndicatorImp.h

@@ -152,10 +152,16 @@ class HKU_API IndicatorImp : public enable_shared_from_this<IndicatorImp> {
     bool isPythonObject() const noexcept;
 
     /**
-     * Whether this implementation can be fully recalculated on a reusable batch executor.
-
-     * * Custom C++ indicators that retain state outside IndicatorImp buffers should opt out.
- */
+     * 该实现是否可在可复用的批处理执行器上被反复重算。
+     *
+     * 默认放行（非 Python 实现、且未显式置 `_support_batch_reuse=false` 都视为可复用）。
+     * 参与复用意味着同一节点的计算图会被 `CompiledFactorPlan` 跨股票反复重绑 context
+     * 并重算，因此自定义 C++ 指标必须满足：除 IndicatorImp 自身的 result buffer 与
+     * `m_params/m_ind_params` 外，不持有任何跨股票会残留的成员状态（如缓存统计量、可变
+     * 缓冲、上次输入依赖的中间结果等）。凡是会在 `_calculate`/`_dyn_calculate` 外部保留
+     * 上述状态、或无法通过 `scrubTemplateNode` 重置干净的实现，都应在构造时调用
+     * `supportBatchReuse(false)` 主动退出快速路径，回退到旧行为。
+     */
     bool supportBatchReuse() const;
 
     void supportBatchReuse(bool enable);

hikyuu_cpp/hikyuu/indicator/imp/IFactor.cpp

@@ -15,10 +15,12 @@ namespace hku {
 
 IFactor::IFactor() : IndicatorImp("FACTOR", 1) {
     m_need_context = true;
+    m_need_self_alike_compare = true;
 }
 
 IFactor::IFactor(const Factor& factor) : IndicatorImp("FACTOR", 1), m_factor(factor) {
     m_need_context = true;
+    m_need_self_alike_compare = true;
 }
 
 IFactor::~IFactor() {}
@@ -32,9 +34,15 @@ IndicatorImpPtr IFactor::_clone() {
 }
 
 bool IFactor::selfAlike(const IndicatorImp& other) const noexcept {
+    // Factor 以“名字 + K线类型”作为唯一标识（见 Factor.h 文档），故意不比较公式内容。
+    // 因此两个 FACTOR 节点仅在名字和 K线类型都相同时，才会被 CompiledFactorPlan
+    // 当作同一节点做 CSE 合并。上游 FactorSet::add 已校验 K线类型并按名字去重
+    //（后加入者覆盖先加入者），所以结构良好的 FactorSet 不会把“标识相同但公式不同”
+    // 的两个因子同时喂进 compiled 路径。dynamic_cast 保证非 IFactor 节点不会判等。
     const auto* other_ctx = dynamic_cast<const IFactor*>(&other);
     HKU_IF_RETURN(other_ctx == nullptr, false);
-    return m_factor.name() == other_ctx->m_factor.name();
+    return m_factor.name() == other_ctx->m_factor.name() &&
+           m_factor.ktype() == other_ctx->m_factor.ktype();
 }
 
 void IFactor::_calculate(const Indicator& data) {

hikyuu_cpp/unit_test/hikyuu/factor/test_FactorSet.cpp

@@ -16,6 +16,7 @@
 #include <hikyuu/indicator/crt/CORR.h>
 #include <hikyuu/indicator/crt/CVAL.h>
 #include <hikyuu/indicator/crt/EMA.h>
+#include <hikyuu/indicator/crt/FACTOR.h>
 #include <hikyuu/indicator/crt/MA.h>
 #include <hikyuu/indicator/crt/KDATA.h>
 #include <hikyuu/indicator/crt/REF.h>
@@ -1342,6 +1343,36 @@ TEST_CASE("test_FactorSet_compiled_values_match_legacy") {
     }
 }
 
+TEST_CASE("test_FactorSet_compiled_values_keep_nested_factors_distinct") {
+    Stock stock = StockManager::instance().getStock("sh000001");
+    REQUIRE_FALSE(stock.isNull());
+
+    Factor close_ma5("INNER_CLOSE_MA5", MA(CLOSE(), 5), KQuery::DAY);
+    Factor high_ma3("INNER_HIGH_MA3", MA(HIGH(), 3), KQuery::DAY);
+    FactorSet factorset("NESTED_FACTORS", KQuery::DAY);
+    factorset.add("OUTER_CLOSE_MA5", FACTOR(close_ma5));
+    factorset.add("OUTER_HIGH_MA3", FACTOR(high_ma3));
+
+    KQuery query(0, 30, KQuery::DAY);
+    KData kdata = stock.getKData(query);
+    REQUIRE_FALSE(kdata.empty());
+
+    auto compiled = factorset.getValues({stock}, query, false, false, true);
+    auto legacy = factorset.getValues({stock}, query, false, false, false);
+    REQUIRE_EQ(compiled.size(), 1);
+    REQUIRE_EQ(compiled[0].size(), 2);
+    REQUIRE_EQ(legacy.size(), 1);
+    REQUIRE_EQ(legacy[0].size(), 2);
+
+    Indicator expected_close_ma5 = FACTOR(close_ma5)(kdata).getResult(0);
+    Indicator expected_high_ma3 = FACTOR(high_ma3)(kdata).getResult(0);
+    check_indicator(compiled[0][0], expected_close_ma5);
+    check_indicator(compiled[0][1], expected_high_ma3);
+    check_indicator(legacy[0][0].getResult(0), expected_close_ma5);
+    check_indicator(legacy[0][1].getResult(0), expected_high_ma3);
+    CHECK_FALSE(compiled[0][0].equal(compiled[0][1]));
+}
+
 TEST_CASE("test_FactorSet_formula_results_keep_independent_graphs") {
     Stock stock = StockManager::instance().getStock("sh000001");
     REQUIRE_FALSE(stock.isNull());

hikyuu_cpp/unit_test/hikyuu/indicator/test_FACTOR.cpp

@@ -92,6 +92,17 @@ TEST_CASE("test_FACTOR_different_factors") {
     check_indicator(result2, ma3_result);
 }
 
+TEST_CASE("test_FACTOR_alike_uses_factor_identity") {
+    Factor close_ma5("CLOSE_MA5", MA(CLOSE(), 5), KQuery::DAY);
+    Factor high_ma3("HIGH_MA3", MA(HIGH(), 3), KQuery::DAY);
+    Factor same_identity_different_formula("CLOSE_MA5", MA(HIGH(), 3), KQuery::DAY);
+    Factor same_name_different_ktype("CLOSE_MA5", MA(CLOSE(), 5), KQuery::WEEK);
+
+    CHECK_FALSE(FACTOR(close_ma5).alike(FACTOR(high_ma3)));
+    CHECK_UNARY(FACTOR(close_ma5).alike(FACTOR(same_identity_different_formula)));
+    CHECK_FALSE(FACTOR(close_ma5).alike(FACTOR(same_name_different_ktype)));
+}
+
 //-----------------------------------------------------------------------------
 // test export
 //-----------------------------------------------------------------------------
@@ -136,4 +147,4 @@ TEST_CASE("test_FACTOR_export") {
 }
 #endif /* #if HKU_SUPPORT_SERIALIZATION */
 
-/** @} */
+/** @} */

hikyuu_cpp/unit_test/hikyuu/indicator/test_Indicator.cpp

@@ -71,6 +71,15 @@ TEST_CASE("test_indicator_alike_dynamic_parameters") {
 
     CHECK_FALSE(corr_close.alike(corr_high));
     CHECK_UNARY(corr_close.alike(corr_close_copy));
+
+    Indicator corr_open_template = CORR(OPEN(), 10);
+    Indicator corr_high_template = CORR(HIGH(), 10);
+    Indicator corr_open_template_copy = CORR(OPEN(), 10);
+
+    CHECK_FALSE(corr_open_template.alike(corr_high_template));
+    CHECK_UNARY(corr_open_template.alike(corr_open_template_copy));
+
+    CHECK_FALSE(DROPNA(CLOSE()).alike(DROPNA(CLOSE())));
 }
 
 /** @par 检测点 */