[Doc-17728][Master] Update load-balance doc (#17735)

Author: Mrhs121

docs/docs/en/architecture/load-balance.md

@@ -1,52 +1,89 @@
-# Load Balance
+# Load Balancing
 
-Load balancing refers to the reasonable allocation of server pressure through routing algorithms (usually in cluster environments) to achieve the maximum optimization of server performance.
+Load balancing distributes server pressure reasonably through routing algorithms (typically in cluster environments) to optimize server performance to the maximum extent.
 
 ## DolphinScheduler-Worker Load Balancing Algorithms
 
-DolphinScheduler-Master allocates tasks to workers, and by default provides three algorithms:
+DolphinScheduler-Master provides four load balancing algorithms for distributing tasks to workers:
 
-- Weighted random (random)
+- **Random** (RANDOM)
+- **Round Robin** (ROUND_ROBIN)
+- **Smooth Round Robin** (FIXED_WEIGHTED_ROUND_ROBIN)
+- **Dynamic Smooth Round Robin** (DYNAMIC_WEIGHTED_ROUND_ROBIN) - Default algorithm
 
-- Smoothing polling (round-robin)
+## Load Balancing Configuration
 
-- Linear load (lower weight)
+Configure the load balancing algorithm in the configuration file:
 
-The default configuration is the linear load.
+Location: `master-server/conf/application.yaml`
 
-As the routing sets on the client side, the master service, you can change master.host.selector in master.properties to configure the algorithm.
+```yaml
+worker-load-balancer-configuration-properties:
+  # types: RANDOM, ROUND_ROBIN, FIXED_WEIGHTED_ROUND_ROBIN, DYNAMIC_WEIGHTED_ROUND_ROBIN
+  type: DYNAMIC_WEIGHTED_ROUND_ROBIN
+```
 
-e.g. master.host.selector=random (case-insensitive)
+## Worker Weight Configuration
 
-## Worker Load Balancing Configuration
+### Smooth Round Robin Configuration (FIXED_WEIGHTED_ROUND_ROBIN)
 
-The configuration file is worker.properties
+For the `FIXED_WEIGHTED_ROUND_ROBIN` algorithm, you can modify the fixed weight in each worker's configuration file:
 
-### Weight
+Location: `worker-server/conf/application.yaml`
 
-All the load algorithms above are weighted based on weights, which affect the routing outcome. You can set different weights for different machines by modifying the `worker.weight` value.
+```yaml
+worker:
+  host-weight: 100 #default value is 100
+```
 
-### Preheating
+### Dynamic Smooth Round Robin Configuration (DYNAMIC_WEIGHTED_ROUND_ROBIN)
 
-Consider JIT optimization, worker runs at low power for a period of time after startup, so that it can gradually reach its optimal state, a process we call preheating. If you are interested, you can read some articles about JIT.
+When using the `DYNAMIC_WEIGHTED_ROUND_ROBIN` algorithm, you can configure the weights for various metrics:
 
-So the worker gradually reaches its maximum weight with time after starts up ( by default ten minutes, there is no configuration about the pre-heating duration, it's recommend to submit a PR if have needs to change the duration).
+```yaml
+master:
+  worker-load-balancer-configuration-properties:
+    type: DYNAMIC_WEIGHTED_ROUND_ROBIN
+    # Dynamic weight configuration, only used for DYNAMIC_WEIGHTED_ROUND_ROBIN algorithm
+    # The sum of memory-usage, cpu-usage, task-thread-pool-usage weights must be 100
+    dynamic-weight-config-properties:
+      memory-usage-weight: 30    # Memory usage weight
+      cpu-usage-weight: 30       # CPU usage weight  
+      task-thread-pool-usage-weight: 40  # Task thread pool usage weight
+```
 
-## Load Balancing Algorithm in Details
+## Load Balancing Algorithm Details
 
-### Random (Weighted)
+### Random (RANDOM)
 
-This algorithm is relatively simple, select a worker by random (the weight affects its weighting).
+Randomly selects one available worker node to execute tasks.
 
-### Smoothed Polling (Weighted)
+### Round Robin (ROUND_ROBIN)
 
-An obvious drawback of the weighted polling algorithm, which is under special weights circumstance, weighted polling scheduling generates an imbalanced sequence of instances, and this unsmooth load may cause some instances to experience transient high loads, leading to a risk of system crash. To address this scheduling flaw, we provide a smooth weighted polling algorithm.
+Selects worker nodes in a fixed order to ensure each worker receives tasks evenly.
 
-Each worker has two weights parameters, weight (which remains constant after warm-up is complete) and current_weight (which changes dynamically). For every route, calculate the current_weight + weight and is iterated over all the workers, the weight of all the workers sum up and count as total_weight, then the worker with the largest current_weight is selected as the worker for this task. By meantime, set worker's current_weight-total_weight.
+### Smooth Round Robin (FIXED_WEIGHTED_ROUND_ROBIN)
 
-### Linear Weighting (Default Algorithm)
+Each worker has two weights: weight (remains constant after warm-up) and current_weight (dynamically changes). During each routing, all workers are traversed, and their current_weight is increased by their weight. The total weight of all workers is accumulated as total_weight. The worker with the highest current_weight is selected to execute the task, and then that worker's current_weight is decreased by total_weight.
 
-This algorithm reports its own load information to the registry at regular intervals. We mainly judge by CPU usage, memory usage and worker slot usage.
+- Example: For instance, with 3 workers (A, B, C) having weights of 1, 2, and 3 respectively
+- Worker selection order will be: C B C A B C C B C A B C C B C A B C C B C A B C C B C A B C ... (In this 30-round scheduling example, the number of tasks allocated to each worker is: C:15, B:10, A:5, exactly matching the weight ratio)
 
-If either of these is lower than the configured item, then this worker will not participate in the load. (no traffic will be allocated)
+### Dynamic Smooth Round Robin (DYNAMIC_WEIGHTED_ROUND_ROBIN) - Default Algorithm
 
+This algorithm reports its own load information to the registry at regular intervals. We primarily evaluate based on CPU usage, memory usage, and worker thread pool usage, with specific weight configurations as follows:
+- **Memory Usage** (Default weight: 30%)
+- **CPU Usage** (Default weight: 30%)
+- **Task Thread Pool Usage** (Default weight: 40%)
+
+**Weight Calculation Principle:**
+The dynamic weight of each worker is calculated using the following formula:
+
+```
+Weight = 100 - (CPU Weight × CPU Usage + Memory Weight × Memory Usage + Thread Pool Weight × Thread Pool Usage) ÷ 3
+```
+
+Therefore, when a worker's load is lower, its weight will be higher, and the system will prioritize selecting worker nodes with lower loads to execute tasks.
+
+In the final worker node selection process, the workflow is consistent with smooth round robin, with the only difference being that in this algorithm, worker weights change dynamically.
+Through this dynamic smooth round robin algorithm, DolphinScheduler can intelligently distribute tasks to workers with the lowest loads, achieving true dynamic load balancing.

docs/docs/zh/architecture/load-balance.md

@@ -1,52 +1,91 @@
-### 负载均衡
+# 负载均衡
 
 负载均衡即通过路由算法（通常是集群环境），合理的分摊服务器压力，达到服务器性能的最大优化。
 
-### DolphinScheduler-Worker 负载均衡算法
+## DolphinScheduler-Worker 负载均衡算法
 
-DolphinScheduler-Master 分配任务至 worker,默认提供了三种算法:
+DolphinScheduler-Master 分配任务至 worker，提供了四种负载均衡算法：
 
-加权随机（random）
+- **随机** (RANDOM)
+- **轮询** (ROUND_ROBIN)
+- **平滑轮询** (FIXED_WEIGHTED_ROUND_ROBIN)
+- **动态平滑轮询** (DYNAMIC_WEIGHTED_ROUND_ROBIN) - 默认算法
 
-平滑轮询（roundrobin）
+## 负载均衡算法配置
 
-线性负载（lowerweight）
+在配置文件中配置负载均衡算法：
 
-默认配置为线性加权负载。
+位置：`master-server/conf/application.yaml`
 
-由于路由是在客户端做的，即 master 服务，因此你可以更改 master.properties 中的 master.host.selector 来配置你所想要的算法。
+```yaml
+worker-load-balancer-configuration-properties:
+  # 负载均衡算法类型：RANDOM, ROUND_ROBIN, FIXED_WEIGHTED_ROUND_ROBIN, DYNAMIC_WEIGHTED_ROUND_ROBIN
+  type: DYNAMIC_WEIGHTED_ROUND_ROBIN
+```
 
-eg：master.host.selector=random（不区分大小写）
+## Worker 权重配置
 
-### Worker 负载均衡配置
+### 平滑轮询权重配置 (FIXED_WEIGHTED_ROUND_ROBIN)
 
-配置文件 worker.properties
+对于 `FIXED_WEIGHTED_ROUND_ROBIN` 算法，可以在每个 worker 的配置文件中修改固定权重：
 
-#### 权重
+位置：`worker-server/conf/application.yaml`
 
-上述所有的负载算法都是基于权重来进行加权分配的，权重影响分流结果。你可以在 修改 worker.weight 的值来给不同的机器设置不同的权重。
+```yaml
+worker:
+  host-weight: 100 #默认值为 100
+```
 
-#### 预热
+### 动态平滑轮询权重配置 (DYNAMIC_WEIGHTED_ROUND_ROBIN)
 
-考虑到 JIT 优化，我们会让 worker 在启动后低功率的运行一段时间，使其逐渐达到最佳状态，这段过程我们称之为预热。感兴趣的同学可以去阅读 JIT 相关的文章。
+当使用 `DYNAMIC_WEIGHTED_ROUND_ROBIN` 算法时，可以配置各项指标的权重：
 
-因此 worker 在启动后，他的权重会随着时间逐渐达到最大（默认十分钟，我们没有提供配置项，如果需要，你可以修改并提交相关的 PR）。
+位置：`master-server/conf/application.yaml`
 
-### 负载均衡算法细述
+```yaml
+master:
+  worker-load-balancer-configuration-properties:
+    type: DYNAMIC_WEIGHTED_ROUND_ROBIN
+    # 动态权重配置，仅用于 DYNAMIC_WEIGHTED_ROUND_ROBIN 算法
+    # memory-usage、cpu-usage、task-thread-pool-usage 的权重总和必须为 100
+    dynamic-weight-config-properties:
+      memory-usage-weight: 30    # 内存使用率权重
+      cpu-usage-weight: 30       # CPU 使用率权重  
+      task-thread-pool-usage-weight: 40  # 任务线程池使用率权重
+```
 
-#### 随机（加权）
+## 负载均衡算法详解
 
-该算法比较简单，即在符合的 worker 中随机选取一台（权重会影响他的比重）。
+### 随机 (RANDOM)
 
-#### 平滑轮询（加权）
+在可用的 worker 节点中随机选择一台执行任务。
 
-加权轮询算法一个明显的缺陷。即在某些特殊的权重下，加权轮询调度会生成不均匀的实例序列，这种不平滑的负载可能会使某些实例出现瞬时高负载的现象，导致系统存在宕机的风险。为了解决这个调度缺陷，我们提供了平滑加权轮询算法。
+### 轮询 (ROUND_ROBIN)
 
-每台 worker 都有两个权重，即 weight（预热完成后保持不变），current_weight（动态变化），每次路由。都会遍历所有的 worker，使其 current_weight+weight，同时累加所有 worker 的 weight，计为  total_weight，然后挑选 current_weight 最大的作为本次执行任务的 worker，与此同时，将这台 worker 的 current_weight-total_weight。
+按照固定的顺序依次选择 worker 节点执行任务，确保每个 worker 都能均匀分配到任务。
 
-#### 线性加权(默认算法)
+### 平滑轮询 (FIXED_WEIGHTED_ROUND_ROBIN)
 
-该算法每隔一段时间会向注册中心上报自己的负载信息。我们主要根据CPU使用率、内存使用率以及 worker slot 使用情况来进行判断
+每台 worker 都有两个权重，即 weight（预热完成后保持不变），
+current_weight（动态变化），每次路由。都会遍历所有的 worker，使其 current_weight+weight，同时累加所有 worker 的 weight，计为 total_weight，然后挑选 current_weight 最大的作为本次执行任务的 worker，与此同时，将这台 worker 的 current_weight-total_weight。
+- 示例：例如有 3 个 worker （A, B, C） 的权重分别为 1、2、3
+- worker 选择顺序将为：C B C A B C C B C A B C C B C A B C C B C A B C C B C A B C ... (在上述30轮的调度例子中，每个 worker 分配任务数量：C:15, B:10, A:5, 恰好与权重比例相匹配)
 
-如果任何一个低于配置项，那么这台 worker 将不参与负载。（即不分配流量）
+### 动态平滑轮询 (DYNAMIC_WEIGHTED_ROUND_ROBIN) - 默认算法
 
+该算法每隔一段时间 worker 会向注册中心上报自己的负载信息。我们主要根据CPU使用率、
+内存使用率以及 worker 线程池使用率使用情况来进行判断，具体权重配置如下：
+- **内存使用率** (默认权重 30%)
+- **CPU 使用率** (默认权重 30%)
+- **任务线程池使用率** (默认权重 40%)
+
+每个 worker 的动态权重通过以下公式计算：
+
+```
+权重 = 100 - (CPU权重 × CPU使用率 + 内存权重 × 内存使用率 + 线程池权重 × 线程池使用率) ÷ 3
+```
+
+所以当 worker 的负载越低权重就会越高，系统会优先选择负载较低的 worker 节点执行任务。
+
+在最终选择 worker 节点时，流程与平滑轮询相同，唯一的区别是，该算法下 worker 的权重会动态变化。
+通过这种动态平滑轮询算法，DolphinScheduler 能够智能地将任务分配到负载最低的 worker 上，实现真正的动态负载均衡。