fix

Author: wangzaijun

lightllm/server/router/model_infer/mode_backend/multi_level_kv_cache.py

@@ -102,39 +102,47 @@ def offload_finished_reqs_to_cpu_cache(self, finished_reqs: List[InferReq]) -> L
         cpu_stream = g_infer_context.get_cpu_kv_cache_stream()
         for req in finished_reqs:
             # 只有 group_req_id 和 request_id 相同的请求才会被卸载到 cpu cache 中。
-            # 这个限制是为了兼容 diverse 模式下的请求处理。
+            # 这个限制是为了兼容 diverse 模式下的请求处理, 只有主请求才 offload kv 到 cpu
+            # cache 中
             if req.shm_req.group_req_id != req.shm_req.request_id:
                 true_finished_reqs.append(req)
                 continue
 
             # 过滤不适合进行 kv 卸载到 cpu cache 的请求。
-            if req.cur_kv_len < self.args.cpu_cache_token_page_size:
+            if (
+                req.cur_kv_len < self.args.cpu_cache_token_page_size
+                or req.shm_req.input_len <= self.args.cpu_cache_token_page_size
+            ):
                 true_finished_reqs.append(req)
                 continue
 
             # 如果请求已经完成了 cpu cache 的任务，则满足了退出条件
             if req.cpu_cache_task_status.is_finished():
                 true_finished_reqs.append(req)
-            elif req.cpu_cache_task_status.is_running():
-                # 如果请求已经发起过卸载任务，则在当前轮不进行处理
                 continue
-            else:
-                assert req.cpu_cache_task_status.is_not_started()
-                # 必须等待 overlap stream 上的计算任务完成，不然会崩溃
-                if g_infer_context.overlap_stream is not None:
-                    cpu_stream.wait_stream(g_infer_context.overlap_stream)
-                else:
-                    cpu_stream.wait_stream(torch.cuda.current_stream())
 
-                # 发起将请求的 kv cache 卸载到 cpu cache 中的任务
-                trans_task = self._start_kv_cache_offload_task(req=req, cpu_kv_cache_stream=cpu_stream)
-                if trans_task is not None:
-                    self.cpu_cache_handle_queue.append(trans_task)
-                else:
-                    true_finished_reqs.append(req)
+            # 如果请求已经发起过卸载任务且正在卸载过程中，则在当前轮不进行处理
+            if req.cpu_cache_task_status.is_running():
+                continue
+
+            assert req.cpu_cache_task_status.is_not_started()
+            # # 必须等待 overlap stream 上的计算任务完成，不然会崩溃
+            # if g_infer_context.overlap_stream is not None:
+            #     cpu_stream.wait_stream(g_infer_context.overlap_stream)
+            # else:
+            #     cpu_stream.wait_stream(torch.cuda.current_stream())
+
+            # 发起将请求的 kv cache 卸载到 cpu cache 中的任务
+            trans_task = self._start_kv_cache_offload_task(req=req, cpu_kv_cache_stream=cpu_stream)
+
+            # 根据是否成功创建了卸载任务，决定是否将请求加入到处理队列中
+            if trans_task is not None:
+                self.cpu_cache_handle_queue.append(trans_task)
+            else:
+                true_finished_reqs.append(req)
 
         # 必须在这里同步，不然会崩溃
-        cpu_stream.synchronize()
+        # cpu_stream.synchronize()
         return true_finished_reqs
 
     def _start_kv_cache_offload_task(