discrete profiler support agent loop

Author: mengchengTang

verl/experimental/agent_loop/agent_loop.py

@@ -819,6 +819,7 @@ def generate_sequences(self, prompts: DataProto) -> DataProto:
 
         # Fix for Issue #4147: Always call wake_up() to ensure weight sync
         # The wake_up()/sleep() methods internally check free_cache_engine
+        self._start_profile(role="rollout_generate")
         self.wake_up()
         if self.reward_model_manager:
             self.reward_model_manager.wake_up()
@@ -839,8 +840,8 @@ def generate_sequences(self, prompts: DataProto) -> DataProto:
         # calculate performance metrics
         metrics = [output.meta_info.pop("metrics") for output in outputs]  # List[List[Dict[str, str]]]
         timing = self._performance_metrics(metrics, output)
-
         output.meta_info = {"timing": timing, **outputs[0].meta_info}
+        self._stop_profile()
         return output
 
     def _performance_metrics(self, metrics: list[list[dict[str, str]]], output: DataProto) -> dict[str, float]:
@@ -877,6 +878,14 @@ def clear_kv_cache(self):
         """Clear all rollout kv cache, but don`t sleep."""
         self._run_all([replica.clear_kv_cache() for replica in self.rollout_replicas])
 
+    def _start_profile(self, **kwargs):
+        """Start profiling on all rollout replicas."""
+        self._run_all([replica.start_profile(**kwargs) for replica in self.rollout_replicas])
+
+    def _stop_profile(self):
+        """Stop profiling on all rollout replicas."""
+        self._run_all([replica.stop_profile() for replica in self.rollout_replicas])
+
     def _run_all(self, tasks: list[asyncio.Task]):
         async def run_all():
             await asyncio.gather(*tasks)

verl/utils/profiler/mstx_profile.py

@@ -214,6 +214,46 @@ def stop(self):
                 self.profile_npu.stop()
                 NPUProfiler._define_count -= 1
 
+    def capture_start(self, **kwargs):
+        """
+        Pure start interface for manual control, decoupled from training steps but enabling decorators.
+        Starts the profiler and sets 'this_step' to True so that decorated functions are instrumented.
+        """
+        if not (self.enable and self.this_step):
+            return
+
+        message = kwargs.get("message")
+        role = kwargs.get("role")
+        profile_name = message or role
+
+        if not self.discrete:
+            self._manual_range = mark_start_range(message=profile_name)
+        else:
+            self._manual_profiler = get_npu_profiler(
+                contents=self.profile_contents,
+                profile_level=self.profile_level,
+                profile_save_path=self.profile_save_path,
+                analysis=self.analysis,
+                role=role,
+            )
+            self._manual_profiler.start()
+            self._manual_range = mark_start_range(message=profile_name)
+
+    def capture_stop(self):
+        """Pure stop interface."""
+        if not (self.enable and self.this_step):
+            return
+
+        # End manual range
+        if hasattr(self, "_manual_range"):
+            mark_end_range(self._manual_range)
+            del self._manual_range
+
+        if self.discrete and hasattr(self, "_manual_profiler"):
+            self._manual_profiler.step()
+            self._manual_profiler.stop()
+            del self._manual_profiler
+
     def annotate(self, message: Optional[str] = None, role: Optional[str] = None, **kwargs_outer) -> Callable:
         """Decorate a Worker member function to profile the current rank in the current training step.
 

verl/utils/profiler/profile.py

@@ -227,6 +227,12 @@ def start(self, **kwargs):
     def stop(self):
         return getattr(self._impl, "stop", lambda: None)()
 
+    def capture_start(self, **kwargs):
+        return getattr(self._impl, "capture_start", lambda **_: None)(**kwargs)
+
+    def capture_stop(self):
+        return getattr(self._impl, "capture_stop", lambda: None)()
+
     @classmethod
     def annotate(
         cls,

verl/workers/fsdp_workers.py

@@ -1939,6 +1939,16 @@ async def sleep(self):
         await self.trainer_mode()
         return True
 
+    @register(dispatch_mode=Dispatch.DIRECT_ROLLOUT_METHOD)
+    async def start_capture_profile(self, **kwargs):
+        self.profiler.capture_start(**kwargs)
+        return True
+
+    @register(dispatch_mode=Dispatch.DIRECT_ROLLOUT_METHOD)
+    async def stop_capture_profile(self):
+        self.profiler.capture_stop()
+        return True
+
     # ============================ vLLM related ============================
 
     @register(dispatch_mode=Dispatch.DIRECT_ROLLOUT_METHOD)

verl/workers/rollout/replica.py

@@ -216,6 +216,14 @@ async def clear_kv_cache(self):
         """reset kv cache in each rollout server."""
         await asyncio.gather(*[server.clear_kv_cache.remote() for server in self.servers])
 
+    async def start_profile(self, **kwargs):
+        """Start profiling on all workers."""
+        await asyncio.gather(*[worker.start_capture_profile.remote(**kwargs) for worker in self.workers])
+
+    async def stop_profile(self):
+        """Stop profiling on all workers."""
+        await asyncio.gather(*[worker.stop_capture_profile.remote() for worker in self.workers])
+
 
 class RolloutReplicaRegistry:
     """Factory for managing rollout replica implementations."""