fix

Author: hiworldwzj

lightllm/server/api_cli.py

@@ -241,14 +241,6 @@ def make_argument_parser() -> argparse.ArgumentParser:
         help="""aggressive schedule can lead to frequent prefill interruptions during decode.
                 disabling it allows the router_max_wait_tokens parameter to work more effectively.""",
     )
-    parser.add_argument(
-        "--dp_prefill_wait_step",
-        type=int,
-        default=0,
-        help="""dp_prefill_wait_step is used to control the pacing of dp chunked prefill mode, aiming to reduce
-                computational waste during prefill. However, higher values can negatively impact the
-                first token latency. It is generally recommended to set this value between 0 and 12.""",
-    )
 
     parser.add_argument(
         "--use_dynamic_prompt_cache", action="store_true", help="This argument is deprecated and no longer in use."

lightllm/server/core/objs/req.py

@@ -310,7 +310,7 @@ def get_tuple_tokens(self, is_busy, router_max_new_token_len):
         # 就是通过模拟加长其输出token长度，来延长其在估计阶段的生命周期。max_waiting_token
         # 的计算是保守的，每次chuncked prefill 延迟的最大步数为两种模式之合，因为
         # 这个并不会导致预估的token占用量大幅增加，所以可以放心使用。
-        max_waiting_token = args.router_max_wait_tokens + args.dp_prefill_wait_step
+        max_waiting_token = args.router_max_wait_tokens
         has_out_len = self.shm_cur_output_len
         if self.sample_params.ignore_eos:
             cur_max_new_token_len = self.sample_params.max_new_tokens

lightllm/server/core/objs/start_args_type.py

@@ -49,7 +49,6 @@ class StartArgs:
     router_token_ratio: float = field(default=0.0)
     router_max_new_token_len: int = field(default=1024)
     router_max_wait_tokens: int = field(default=1)
-    dp_prefill_wait_step: int = field(default=0)
     disable_aggressive_schedule: bool = field(default=False)
     disable_dynamic_prompt_cache: bool = field(default=False)
     chunked_prefill_size: int = field(default=8192)

lightllm/server/router/model_infer/mode_backend/dp_backend/control_state.py

@@ -16,10 +16,6 @@ def __init__(self, backend: ModeBackend):
         self.left_decode_num = self.decode_max_step
 
         self.step_count = 0
-
-        # dp prefill 配平调度的延迟参数。
-        self.dp_prefill_wait_step = 0
-        self.dp_prefill_wait_max_step = get_env_start_args().dp_prefill_wait_step
         return
 
     def select_run_way(
@@ -71,48 +67,23 @@ def _normal_way(
         prefill_reqs: List[InferReq],
         decode_reqs: List[InferReq],
     ):
-        """
-        _normal_way 接口用于控制 DP 模式下进行chuncked prefill时，需要考虑各个DP的真实运行请求数量：
-        考虑 8 个 dp 的场景，如果每个 dp 执行 prefill 的请求的数量分别为: [1, 1, 0, 0, 0, 0, 0, 0], 则在运行
-        的过程中，请求数量为0的dp会pad一个fake req来参与计算，但是这会导致这些dp因为一些通信同步的原因，造成大量
-        算力浪费，实际有效率很低。
-        解决方法：
-        在判断是否可以进行 prefill 的时候，需要先考虑所有dp的请求数量是否均衡，浪费率是否在可以接受的范围，如果无法
-        接受这么高的浪费率，则可以延迟 prefill 的执行时机，直到所有dp的浪费率较低时再进行prefill, 不过延迟执行的极限
-        等待时间，受到 dp_prefill_wait_step 参数的控制。
-        """
-        use_ratio = np.count_nonzero(dp_prefill_req_nums) / dp_prefill_req_nums.shape[0]
+        # use_ratio = np.count_nonzero(dp_prefill_req_nums) / dp_prefill_req_nums.shape[0]
         max_decode_num = np.max(dp_decode_req_nums)
         max_prefill_num = np.max(dp_prefill_req_nums)
 
         if self.left_decode_num > 0 and max_decode_num > 0:
             self.left_decode_num -= 1
             return RunWay.DECODE
 
-        if use_ratio < 0.6:
-            if max_prefill_num > 0:
-                self.dp_prefill_wait_step += 1
-                if self.dp_prefill_wait_step > self.dp_prefill_wait_max_step:
-                    # prefill 一次允许进行几次 decode 操作。
-                    self.left_decode_num = self.decode_max_step
-                    self.dp_prefill_wait_step = max(0, (self.dp_prefill_wait_step - self.decode_max_step))
-                    return RunWay.PREFILL
-
+        if max_prefill_num > 0:
+            # prefill 一次允许进行几次 decode 操作。
+            self.left_decode_num = self.decode_max_step
+            return RunWay.PREFILL
+        else:
             if max_decode_num > 0:
                 return RunWay.DECODE
             else:
                 return RunWay.PASS
-        else:
-            if max_prefill_num > 0:
-                self.dp_prefill_wait_step = 0
-                # prefill 一次允许进行几次 decode 操作。
-                self.left_decode_num = self.decode_max_step
-                return RunWay.PREFILL
-            else:
-                if max_decode_num > 0:
-                    return RunWay.DECODE
-                else:
-                    return RunWay.PASS
 
     def try_recover_paused_reqs(self) -> bool:
         return self.step_count % 100 == 0