@ohos-graphics/stability-code-review 0.1.0

package/references/PerformanceStability/StabilityCodeReview_PerformanceStability_001.md

@@ -0,0 +1,380 @@
+---
+rule_id: "StabilityCodeReview_PerformanceStability_001"
+name: "递归条件未考虑充分导致无限递归"
+category: "性能稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 递归条件未考虑充分导致无限递归
+
+## 问题描述
+
+递归函数如果没有正确的终止条件或终止条件考虑不充分，在某些输入情况下可能无法终止，导致无限递归、栈溢出和进程崩溃。这类问题隐蔽性强，通常在特定边界条件下触发，严重影响系统稳定性。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：缺少终止条件
+int CalculateFactorial(int n)
+{
+    return n * CalculateFactorial(n - 1);  // 危险：无终止条件，永远递归
+}
+
+// 错误示例2：终止条件不完整
+int Fibonacci(int n)
+{
+    if (n == 0) return 0;  // 只考虑了 n==0 的情况
+    return Fibonacci(n - 1) + Fibonacci(n - 2);  // 危险：n<0 时无限递归
+}
+
+// 错误示例3：终止条件永远无法满足
+void ProcessNode(Node* node)
+{
+    if (node == nullptr) return;
+    ProcessNode(node);  // 危险：传入相同节点，无法终止
+}
+
+// 错误示例4：终止条件逻辑错误
+int BinarySearch(int* arr, int left, int right, int target)
+{
+    if (left >= right) return -1;
+    int mid = (left + right) / 2;
+    if (arr[mid] == target) return mid;
+    if (arr[mid] > target) {
+        return BinarySearch(arr, left, mid, target);  // 危险：应该是 mid-1
+    }
+    return BinarySearch(arr, mid, right, target);  // 危险：应该是 mid+1
+}
+
+// 错误示例5：深度递归无保护
+void TraverseTree(TreeNode* node)
+{
+    if (node == nullptr) return;
+    Process(node);
+    for (auto child : node->children) {
+        TraverseTree(child);  // 危险：恶意构造的超深树导致栈溢出
+    }
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：添加完整的终止条件
+int CalculateFactorial(int n)
+{
+    if (n <= 1) return 1;  // 安全：明确的终止条件
+    return n * CalculateFactorial(n - 1);
+}
+
+// 正确示例2：完整的终止条件处理
+int Fibonacci(int n)
+{
+    if (n < 0) {  // 安全：处理所有边界情况
+        LOGE("Invalid input: n must be non-negative");
+        return -1;
+    }
+    if (n <= 1) return n;  // 安全：n==0 和 n==1 都终止
+    return Fibonacci(n - 1) + Fibonacci(n - 2);
+}
+
+// 正确示例3：正确的递归调用
+void ProcessNode(Node* node)
+{
+    if (node == nullptr) return;
+    Process(node);
+    for (auto child : node->children) {
+        ProcessNode(child);  // 安全：传入子节点
+    }
+}
+
+// 正确示例4：修正递归逻辑
+int BinarySearch(int* arr, int left, int right, int target)
+{
+    if (left > right) return -1;  // 安全：正确的终止条件
+    int mid = left + (right - left) / 2;
+    if (arr[mid] == target) return mid;
+    if (arr[mid] > target) {
+        return BinarySearch(arr, left, mid - 1, target);  // 安全：排除mid
+    }
+    return BinarySearch(arr, mid + 1, right, target);  // 安全：排除mid
+}
+
+// 正确示例5：添加深度限制（实际场景的深度值）
+constexpr int MAX_NESTING_DEPTH = 800;  // 实际代码中常用的深度限制
+constexpr int RECORD_CMD_MAX_DEPTH = 800;
+
+void TraverseTree(TreeNode* node, int depth = 0)
+{
+    if (node == nullptr) return;
+    if (depth >= MAX_NESTING_DEPTH) {  // 安全：深度保护
+        LOGE("Tree depth exceeded limit: %d", depth);
+        return;
+    }
+    Process(node);
+    for (auto child : node->children) {
+        TraverseTree(child, depth + 1);
+    }
+}
+
+// 正确示例5b：序列化/反序列化深度检查的两种模式
+bool MarshallingData(Data* data, int& recordCmdDepth)
+{
+    if (++recordCmdDepth > RECORD_CMD_MAX_DEPTH) {  // Marshalling: 先递增再检查
+        ROSEN_LOGE("exceed max depth");
+        return false;
+    }
+    // 序列化处理
+    return true;
+}
+
+bool UnmarshallingData(Parcel& parcel, int depth)
+{
+    if (depth >= MAX_NESTING_DEPTH) {  // Unmarshalling: 先检查再处理
+        LOGE("depth exceeds maximum limit");
+        return false;
+    }
+    // 反序列化处理
+    return true;
+}
+
+// 正确示例6：使用迭代替代递归
+int FibonacciIterative(int n)
+{
+    if (n < 0) return -1;
+    if (n <= 1) return n;
+    
+    int prev = 0, curr = 1;
+    for (int i = 2; i <= n; i++) {
+        int next = prev + curr;
+        prev = curr;
+        curr = next;
+    }
+    return curr;  // 安全：无递归风险
+}
+
+// 正确示例7：使用Visitor模式替代传统递归
+class RenderVisitor {
+public:
+    void PrepareChildren(RSRenderNode& node) {
+        for (auto& child : *node.GetSortedChildren()) {  // 迭代器遍历
+            child->Prepare(shared_from_this());  // visitor调用，避免传统递归
+        }
+    }
+    
+    void PrepareNode(RSRenderNode& node) {
+        if (!canvas_) { return; }  // 终止条件1：canvas无效
+        if (!node.ShouldPaint()) { return; }  // 终止条件2：节点不可见
+        // 多重终止条件保护
+        
+        PrepareChildren(node);  // 所有条件通过后才遍历子节点
+    }
+};
+```
+
+## 检测范围
+
+检查以下递归模式：
+
+1. 函数直接调用自身的直接递归
+2. 函数通过其他函数间接调用的间接递归
+3. 递归函数中缺少`return`语句或条件判断
+4. 递归终止条件只覆盖部分边界情况
+5. 递归深度未限制的场景
+
+## 检测要点
+
+1. 识别递归函数：函数体中调用自身或形成调用环
+2. 检查是否存在终止条件：`if`语句中包含`return`
+3. 检查终止条件是否充分：覆盖所有可能的输入情况
+4. 检查递归深度限制：是否存在深度保护机制
+5. 排除NOPROTECT标记的代码
+
+### 实际深度限制值参考
+
+不同场景需要不同的深度限制：
+
+- **数据结构遍历**：100-200（简单树结构）
+- **序列化/反序列化**：800-1000（复杂嵌套对象）
+- **实际代码常用值**：MAX_NESTING_DEPTH = 800, RECORD_CMD_MAX_DEPTH = 800
+
+**深度检查的两种模式**：
+
+- **Marshalling（序列化）**：`if (++depth > MAX_DEPTH)` - 先递增再检查
+- **Unmarshalling（反序列化）**：`if (depth >= MAX_DEPTH)` - 先检查再处理
+
+### Visitor模式替代传统递归
+
+现代C++常用Visitor模式遍历树结构，避免传统递归：
+
+- **优势**：
+  - 迭代器遍历子节点，自然终止
+  - 不使用传统的函数递归调用
+  - 通过迭代器终止条件控制深度
+
+- **典型模式**：
+  ```cpp
+  void PrepareChildren(Node& node) {
+      for (auto& child : *node.GetChildren()) {  // 迭代器
+          child->Prepare(visitor);  // visitor调用
+      }
+  }
+  ```
+
+- **注意**：Visitor模式虽然避免了传统递归，但仍可能形成间接递归（见规则002）
+
+### 多重终止条件保护
+
+实际代码中常使用多重终止条件：
+
+- nullptr检查：`if (!canvas_) return;`
+- 有效性检查：`if (!node.IsValid()) return;`
+- 可见性检查：`if (!node.ShouldPaint()) return;`
+- 安全标志检查：`if (isSecurityDisplay_ && ...) return;`
+
+多重条件可以提前终止，避免深度累积。
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 递归函数中终止条件缺失或条件不充分
+- **RISK_TYPE**: 无限递归风险
+- **RISK_PATH**: 递归调用无法终止 → 栈帧持续增长 → 栈空间耗尽 → 栈溢出
+- **IMPACT_POINT**: 进程崩溃，可能导致服务中断或系统不稳定
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 递归函数被调用时，传入参数导致终止条件无法满足
+- **Propagation**: 每次递归调用消耗栈空间，无终止条件下栈帧持续累积，最终耗尽栈空间
+- **Consequence**: 栈溢出导致SIGSEGV信号，进程异常终止，影响服务可用性
+- **Mitigation**: 添加明确的终止条件，限制递归深度，或使用迭代替代递归
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有终止条件 | 存在 if-return 模式 | 不报 |
+| 已有深度限制 | 存在 depth/MAX_DEPTH 检查 | 不报 |
+| 尾递归优化 | 尾递归形式且编译器支持 | 谨慎报告 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_PerformanceStability_001_trigger.cpp
+
+// 触发用例1：完全缺少终止条件
+int trigger_bad_1(int n)
+{
+    return n * trigger_bad_1(n - 1);  // 应该触发：无终止条件
+}
+
+// 触发用例2：终止条件不完整
+int trigger_bad_2(int n)
+{
+    if (n == 0) return 0;  // 应该触发：n<0 时无限递归
+    return trigger_bad_2(n - 1) + trigger_bad_2(n - 2);
+}
+
+// 触发用例3：终止条件逻辑错误
+int trigger_bad_3(int* arr, int left, int right, int target)
+{
+    if (left >= right) return -1;
+    int mid = (left + right) / 2;
+    if (arr[mid] == target) return mid;
+    return trigger_bad_3(arr, left, mid, target);  // 应该触发：死循环
+}
+
+// 触发用例4：深度递归无保护
+void trigger_bad_4(TreeNode* node)
+{
+    if (node == nullptr) return;
+    Process(node);
+    for (auto child : node->children) {
+        trigger_bad_4(child);  // 应该触发：无深度限制
+    }
+}
+
+// 触发用例5：传入相同节点导致无限递归
+void trigger_bad_5(Node* node)
+{
+    if (node == nullptr) return;
+    Process(node);
+    trigger_bad_5(node);  // 应该触发：传入相同节点
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_PerformanceStability_001_safe.cpp
+constexpr int MAX_RECURSION_DEPTH = 100;
+
+// 安全用例1：完整的终止条件
+int safe_good_1(int n)
+{
+    if (n <= 1) return 1;  // 安全：完整终止条件
+    return n * safe_good_1(n - 1);
+}
+
+// 安全用例2：边界条件处理
+int safe_good_2(int n)
+{
+    if (n < 0) {  // 安全：处理所有边界
+        LOGE("Invalid input");
+        return -1;
+    }
+    if (n <= 1) return n;
+    return safe_good_2(n - 1) + safe_good_2(n - 2);
+}
+
+// 安全用例3：正确的二分查找
+int safe_good_3(int* arr, int left, int right, int target)
+{
+    if (left > right) return -1;  // 安全：正确终止
+    int mid = left + (right - left) / 2;
+    if (arr[mid] == target) return mid;
+    if (arr[mid] > target) {
+        return safe_good_3(arr, left, mid - 1, target);
+    }
+    return safe_good_3(arr, mid + 1, right, target);
+}
+
+// 安全用例4：有深度限制
+void safe_good_4(TreeNode* node, int depth = 0)
+{
+    if (node == nullptr) return;
+    if (depth > MAX_RECURSION_DEPTH) {  // 安全：深度保护
+        LOGE("Depth exceeded");
+        return;
+    }
+    Process(node);
+    for (auto child : node->children) {
+        safe_good_4(child, depth + 1);
+    }
+}
+
+// 安全用例5：正确的树遍历
+void safe_good_5(TreeNode* node)
+{
+    if (node == nullptr) return;
+    Process(node);
+    for (auto child : node->children) {
+        safe_good_5(child);  // 安全：传入子节点
+    }
+}
+
+// NOPROTECT用例：特殊情况
+// NOPROTECT: 递归深度由外部严格控制
+void noprotect_case(int n)
+{
+    if (n == 0) return;
+    noprotect_case(n - 1);
+}
+```