[PIR] speed up pir interpreter by event (#69513)

wanghuancoder · web-flow · commit ea50ffe2c301 · 2024-11-22T16:06:42.000+08:00
* speed up pir_interpreter on multi stream
diff --git a/paddle/common/flags.cc b/paddle/common/flags.cc
@@ -1588,6 +1588,11 @@ PHI_DEFINE_EXPORTED_bool(logging_pir_py_code_dump_symbolic_dims,
                          false,
                          "whether dump symbolic dims into pir py code.");
 
+PHI_DEFINE_EXPORTED_bool(
+    pir_interpreter_record_stream_for_gc_cache,
+    false,
+    "whether PirInterpreter::RecordStreamForGC use cache strategy.");
+
 /**
  * Using PIR API in Python
  * Name: enable_pir_api
diff --git a/paddle/fluid/framework/new_executor/instruction/instruction_base.cc b/paddle/fluid/framework/new_executor/instruction/instruction_base.cc
@@ -217,20 +217,20 @@ const phi::DeviceContext& InstructionBase::DeviceContext() const {
 }
 
 void InstructionBase::RecordEvent(const Place& place) const {
-  phi::RecordEvent record(
-      "RecordStreamEvent", phi::TracerEventType::UserDefined, 10);
   if (event_to_record_) {
+    phi::RecordEvent record(
+        "RecordStreamEvent", phi::TracerEventType::UserDefined, 10);
     VLOG(6) << "Record event at instruction: " << id_;
     event_to_record_->event_->Record(dev_ctx_);
   }
 }
 
 void InstructionBase::WaitEvent(const Place& place) const {
-  // If InterpreterCore in on CPUPlace, do nothing.
-  if (phi::is_cpu_place(place)) {
-    return;
-  }
   for (const EventInter& event_iter : events_to_wait_) {
+    // If InterpreterCore in on CPUPlace, do nothing.
+    if (phi::is_cpu_place(place)) {
+      continue;
+    }
     phi::RecordEvent record(
         "WaitStreamEvent", phi::TracerEventType::UserDefined, 10);
     VLOG(6) << "Wait instruction: " << event_iter.instr_id_
diff --git a/paddle/fluid/framework/new_executor/instruction/instruction_base.h b/paddle/fluid/framework/new_executor/instruction/instruction_base.h
@@ -175,6 +175,10 @@ class InstructionBase {
   // if scope is not null, also show dimensions of arguments
   virtual std::string DebugStringEx(const paddle::framework::Scope* scope,
                                     ValueExecutionInfo* value_exe_info) const;
+  bool SkipRecordStreamForGC() const { return skip_record_stream_for_gc_; }
+  void SetSkipRecordStreamForGC(bool skip) {
+    skip_record_stream_for_gc_ = skip;
+  }
 
  protected:
   size_t id_;
@@ -224,6 +228,8 @@ class InstructionBase {
   std::unordered_map<::pir::Value, std::vector<int>> output_index_;
 
   std::unordered_set<::pir::Value> no_need_buffer_values_;
+
+  bool skip_record_stream_for_gc_{false};
 };
 
 }  // namespace framework
diff --git a/paddle/fluid/framework/new_executor/new_executor_defs.cc b/paddle/fluid/framework/new_executor/new_executor_defs.cc
@@ -175,14 +175,11 @@ Instruction::Instruction(size_t id,
 }
 
 void Instruction::WaitEvent(const Place& place) const {
-  // If InterpreterCore in on CPUPlace, do nothing.
-  if (phi::is_cpu_place(place)) {
-    return;
-  }
-
-  VLOG(6) << "Deal StreamWaitEventOrSync for " << this->OpBase()->Type();
-
   for (const EventInter& event_iter : events_to_wait_) {
+    // If InterpreterCore in on CPUPlace, do nothing.
+    if (phi::is_cpu_place(place)) {
+      continue;
+    }
     phi::RecordEvent record(
         "WaitStreamEvent", phi::TracerEventType::UserDefined, 10);
     VLOG(6) << "Wait instruction: " << event_iter.instr_id_
@@ -192,9 +189,9 @@ void Instruction::WaitEvent(const Place& place) const {
 }
 
 void Instruction::RecordEvent(const Place& place) const {
-  phi::RecordEvent record(
-      "RecordStreamEvent", phi::TracerEventType::UserDefined, 10);
   if (event_to_record_) {
+    phi::RecordEvent record(
+        "RecordStreamEvent", phi::TracerEventType::UserDefined, 10);
     VLOG(6) << "Record event at instruction: " << id_;
     event_to_record_->event_->Record(&dev_ctx_);
   }
diff --git a/paddle/fluid/framework/new_executor/pir_interpreter.cc b/paddle/fluid/framework/new_executor/pir_interpreter.cc
@@ -88,6 +88,7 @@ COMMON_DECLARE_bool(enable_pir_in_executor);
 COMMON_DECLARE_bool(enable_pir_in_executor_trace_run);
 COMMON_DECLARE_bool(enable_collect_shape);
 COMMON_DECLARE_int32(low_precision_op_list);
+COMMON_DECLARE_bool(pir_interpreter_record_stream_for_gc_cache);
 
 #define CREATE_INSTR(instr_name)                                   \
   vec_instruction_base_.emplace_back(std::make_unique<instr_name>( \
@@ -1149,17 +1150,25 @@ void PirInterpreter::RecordStreamForGC(InstructionBase* instr) {
   PADDLE_THROW(common::errors::Unimplemented(
       "RecordStreamForGC is only implemented when compiled with GPU."));
 #else
+  if (FLAGS_pir_interpreter_record_stream_for_gc_cache &&
+      instr->SkipRecordStreamForGC()) {
+    return;
+  }
+
   if (!IsInterpretercoreFastGCEnabled() ||
       instr->KernelType() != OpFuncType::kGpuAsync) {
+    instr->SetSkipRecordStreamForGC(true);
     return;
   }
   if (instr->DeviceContext().GetPlace().GetType() ==
       phi::AllocationType::CUSTOM) {
+    instr->SetSkipRecordStreamForGC(true);
     return;
   }
   phi::RecordEvent record(
       "RecordStreamForGC", phi::TracerEventType::UserDefined, 10);
 
+  bool skip_record_stream = true;
   gpuStream_t stream =
       reinterpret_cast<const phi::GPUContext&>(instr->DeviceContext()).stream();
 // TODO(lizhiyu): Only analyse the 'send_v2' for GPT pp strategy right now.
@@ -1185,15 +1194,18 @@ void PirInterpreter::RecordStreamForGC(InstructionBase* instr) {
     }
   }
 #endif
-  auto TensorRecordStream = [&stream](phi::DenseTensor& tensor) {
+  auto TensorRecordStream = [&stream, &instr, &skip_record_stream](
+                                phi::DenseTensor& tensor) {
     auto allocation = tensor.Holder();
     if (allocation == nullptr) {
       return;
     }
 
     const phi::Place& place = allocation->place();
     if (phi::is_gpu_place(place)) {
-      memory::RecordStream(allocation, stream);
+      if (memory::RecordStream(allocation, stream)) {
+        skip_record_stream = false;
+      }
     } else if (phi::is_cuda_pinned_place(place)) {
       // TODO(Ruibiao): Here should do something to make sure that the tensor
       // is not freed until the H2D copies done. However, simply launch a
@@ -1279,6 +1291,10 @@ void PirInterpreter::RecordStreamForGC(InstructionBase* instr) {
           framework::ToTypeName(var->Type())));
     }
   }
+
+  if (skip_record_stream) {
+    instr->SetSkipRecordStreamForGC(true);
+  }
 #endif
 }
 
diff --git a/paddle/phi/core/memory/allocation/allocator_facade.cc b/paddle/phi/core/memory/allocation/allocator_facade.cc
@@ -522,19 +522,20 @@ class AllocatorFacadePrivate {
     }
   }
 
-  void RecordStream(std::shared_ptr<phi::Allocation> allocation,
+  bool RecordStream(std::shared_ptr<phi::Allocation> allocation,
                     gpuStream_t stream) {
     if (auto stream_safe_cuda_allocation =
             std::dynamic_pointer_cast<StreamSafeCUDAAllocation>(allocation)) {
-      stream_safe_cuda_allocation->RecordStream(stream);
+      return stream_safe_cuda_allocation->RecordStream(stream);
 #ifdef PADDLE_WITH_CUDA
     } else if (auto cuda_malloc_async_allocation =
                    std::dynamic_pointer_cast<CUDAMallocAsyncAllocation>(
                        allocation)) {
-      cuda_malloc_async_allocation->RecordStream(stream);
+      return cuda_malloc_async_allocation->RecordStream(stream);
 #endif
     } else {
       VLOG(6) << "RecordStream for a non-StreamSafeCUDAAllocation";
+      return false;
     }
   }
 
@@ -659,14 +660,15 @@ class AllocatorFacadePrivate {
             << place;
   }
 
-  void RecordStream(std::shared_ptr<phi::Allocation> allocation,
+  bool RecordStream(std::shared_ptr<phi::Allocation> allocation,
                     XPUStream stream) {
     std::shared_ptr<StreamSafeXPUAllocation> stream_safe_xpu_allocation =
         std::dynamic_pointer_cast<StreamSafeXPUAllocation>(allocation);
     if (stream_safe_xpu_allocation != nullptr) {
-      stream_safe_xpu_allocation->RecordStream(stream);
+      return stream_safe_xpu_allocation->RecordStream(stream);
     } else {
       VLOG(6) << "RecordStream for a non-StreamSafeXPUAllocation";
+      return false;
     }
   }
 
@@ -771,16 +773,17 @@ class AllocatorFacadePrivate {
             << ") in " << place;
   }
 
-  void RecordStream(std::shared_ptr<phi::Allocation> allocation,
+  bool RecordStream(std::shared_ptr<phi::Allocation> allocation,
                     phi::stream::stream_t stream) {
     std::shared_ptr<StreamSafeCustomDeviceAllocation>
         stream_safe_custom_device_allocation =
             std::dynamic_pointer_cast<StreamSafeCustomDeviceAllocation>(
                 allocation);
     if (stream_safe_custom_device_allocation != nullptr) {
-      stream_safe_custom_device_allocation->RecordStream(stream);
+      return stream_safe_custom_device_allocation->RecordStream(stream);
     } else {
       VLOG(6) << "RecordStream for a non-StreamSafeCustomDeviceAllocation";
+      return false;
     }
   }
 
@@ -1789,9 +1792,9 @@ uint64_t AllocatorFacade::Release(const phi::GPUPlace& place,
   return m->GetAllocator(place, stream)->Release(place);
 }
 
-void AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,
+bool AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,
                                    gpuStream_t stream) {
-  GetPrivate()->RecordStream(allocation, stream);
+  return GetPrivate()->RecordStream(allocation, stream);
 }
 
 void AllocatorFacade::EraseStream(std::shared_ptr<phi::Allocation> allocation,
@@ -1913,9 +1916,9 @@ uint64_t AllocatorFacade::Release(const phi::CustomPlace& place,
   return m->GetAllocator(place, stream)->Release(place);
 }
 
-void AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,
+bool AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,
                                    phi::stream::stream_t stream) {
-  GetPrivate()->RecordStream(allocation, stream);
+  return GetPrivate()->RecordStream(allocation, stream);
 }
 
 const std::shared_ptr<Allocator>& AllocatorFacade::GetAllocator(
diff --git a/paddle/phi/core/memory/allocation/allocator_facade.h b/paddle/phi/core/memory/allocation/allocator_facade.h
@@ -87,7 +87,7 @@ class AllocatorFacade {
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
   // TODO(zhiqiu): change gpuStream_t to phi::Stream if needed.
   uint64_t Release(const phi::GPUPlace& place, gpuStream_t stream);
-  void RecordStream(std::shared_ptr<Allocation> allocation, gpuStream_t stream);
+  bool RecordStream(std::shared_ptr<Allocation> allocation, gpuStream_t stream);
   void EraseStream(std::shared_ptr<Allocation> allocation, gpuStream_t stream);
 
   TEST_API const std::shared_ptr<Allocator>& GetAllocator(
@@ -107,7 +107,7 @@ class AllocatorFacade {
 
 #ifdef PADDLE_WITH_CUSTOM_DEVICE
   uint64_t Release(const phi::CustomPlace& place, phi::stream::stream_t stream);
-  void RecordStream(std::shared_ptr<Allocation> allocation,
+  bool RecordStream(std::shared_ptr<Allocation> allocation,
                     phi::stream::stream_t stream);
   TEST_API const std::shared_ptr<Allocator>& GetAllocator(
       const phi::Place& place, phi::stream::stream_t stream);
diff --git a/paddle/phi/core/memory/allocation/cuda_malloc_async_allocator.cc b/paddle/phi/core/memory/allocation/cuda_malloc_async_allocator.cc
@@ -89,16 +89,17 @@ inline void sync_streams(gpuStream_t to_record, gpuStream_t to_wait) {
 
 // CUDAMallocAsyncAllocation
 
-void CUDAMallocAsyncAllocation::RecordStream(gpuStream_t stream) {
+bool CUDAMallocAsyncAllocation::RecordStream(gpuStream_t stream) {
   std::call_once(once_flag_,
                  [this] { phi::backends::gpu::SetDeviceId(place_.device); });
   std::lock_guard<SpinLock> lock_guard(recorded_streams_lock_);
   if (malloc_stream_ == stream) {
     // Called record_stream on tensor whose original malloc_stream matches the
     // recorded stream. This should have no effect.
-    return;
+    return false;
   }
   recorded_streams_.insert(stream);
+  return true;
 }
 
 void CUDAMallocAsyncAllocation::EraseStream(gpuStream_t stream) {
diff --git a/paddle/phi/core/memory/allocation/cuda_malloc_async_allocator.h b/paddle/phi/core/memory/allocation/cuda_malloc_async_allocator.h
@@ -54,7 +54,7 @@ class CUDAMallocAsyncAllocation : public Allocation {
 
   gpuStream_t GetOwningStream() const { return malloc_stream_; }
 
-  void RecordStream(gpuStream_t stream);
+  bool RecordStream(gpuStream_t stream);
   void EraseStream(gpuStream_t stream);
   size_t Free();
 
diff --git a/paddle/phi/core/memory/allocation/stream_safe_cuda_allocator.cc b/paddle/phi/core/memory/allocation/stream_safe_cuda_allocator.cc
@@ -40,10 +40,10 @@ StreamSafeCUDAAllocation::StreamSafeCUDAAllocation(
       owning_stream_(owning_stream),
       allocator_(allocator->shared_from_this()) {}
 
-void StreamSafeCUDAAllocation::RecordStream(gpuStream_t stream) {
+bool StreamSafeCUDAAllocation::RecordStream(gpuStream_t stream) {
   VLOG(8) << "Try record stream " << stream << " for address " << ptr();
   if (stream == owning_stream_) {
-    return;
+    return false;
   }
 
   std::call_once(once_flag_,
@@ -53,12 +53,13 @@ void StreamSafeCUDAAllocation::RecordStream(gpuStream_t stream) {
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
   if (UNLIKELY(phi::backends::gpu::CUDAGraph::IsThisThreadCapturing())) {
     graph_capturing_stream_set_.insert(stream);
-    return;
+    return true;
   }
 #endif
 
   RecordStreamWithNoGraphCapturing(stream);
   RecordGraphCapturingStreams();
+  return true;
 }
 
 void StreamSafeCUDAAllocation::EraseStream(gpuStream_t stream) {
diff --git a/paddle/phi/core/memory/allocation/stream_safe_cuda_allocator.h b/paddle/phi/core/memory/allocation/stream_safe_cuda_allocator.h
@@ -40,7 +40,7 @@ class StreamSafeCUDAAllocation : public Allocation {
                            gpuStream_t owning_stream,
                            StreamSafeCUDAAllocator *allocator);
 
-  void RecordStream(gpuStream_t stream);
+  bool RecordStream(gpuStream_t stream);
   void EraseStream(gpuStream_t stream);
   bool CanBeFreed();
   gpuStream_t GetOwningStream() const;
diff --git a/paddle/phi/core/memory/allocation/stream_safe_custom_device_allocator.cc b/paddle/phi/core/memory/allocation/stream_safe_custom_device_allocator.cc
@@ -34,11 +34,11 @@ StreamSafeCustomDeviceAllocation::StreamSafeCustomDeviceAllocation(
       owning_stream_(std::move(owning_stream)),
       allocator_(allocator->shared_from_this()) {}
 
-void StreamSafeCustomDeviceAllocation::RecordStream(
+bool StreamSafeCustomDeviceAllocation::RecordStream(
     phi::stream::stream_t stream) {
   VLOG(8) << "Try record stream " << stream << " for address " << ptr();
   if (stream == owning_stream_) {
-    return;
+    return false;
   }
   std::call_once(once_flag_, [this] { phi::DeviceManager::SetDevice(place_); });
   std::lock_guard<SpinLock> lock_guard(outstanding_event_map_lock_);
@@ -55,6 +55,7 @@ void StreamSafeCustomDeviceAllocation::RecordStream(
   VLOG(8) << "Record event " << outstanding_event_map_[stream]->raw_event()
           << " to stream " << stream;
   outstanding_event_map_[stream]->Record(&stream_wrapper);
+  return true;
 }
 
 bool StreamSafeCustomDeviceAllocation::CanBeFreed() {
diff --git a/paddle/phi/core/memory/allocation/stream_safe_custom_device_allocator.h b/paddle/phi/core/memory/allocation/stream_safe_custom_device_allocator.h
@@ -35,7 +35,7 @@ class StreamSafeCustomDeviceAllocation : public Allocation {
                                    phi::stream::stream_t owning_stream,
                                    StreamSafeCustomDeviceAllocator *allocator);
 
-  void RecordStream(phi::stream::stream_t stream);
+  bool RecordStream(phi::stream::stream_t stream);
   bool CanBeFreed();
   phi::stream::stream_t GetOwningStream() const;
   void SetOwningStream(phi::stream::stream_t s);
diff --git a/paddle/phi/core/memory/allocation/stream_safe_xpu_allocator.cc b/paddle/phi/core/memory/allocation/stream_safe_xpu_allocator.cc
@@ -35,10 +35,10 @@ StreamSafeXPUAllocation::StreamSafeXPUAllocation(
       owning_stream_(std::move(owning_stream)),
       allocator_(allocator->shared_from_this()) {}
 
-void StreamSafeXPUAllocation::RecordStream(XPUStream stream) {
+bool StreamSafeXPUAllocation::RecordStream(XPUStream stream) {
   VLOG(8) << "Try record stream " << stream << " for address " << ptr();
   if (stream == owning_stream_) {
-    return;
+    return false;
   }
 
   std::call_once(once_flag_,
@@ -47,6 +47,7 @@ void StreamSafeXPUAllocation::RecordStream(XPUStream stream) {
   std::lock_guard<SpinLock> lock_guard(outstanding_event_map_lock_);
 
   RecordStreamPrivate(stream);
+  return true;
 }
 
 bool StreamSafeXPUAllocation::CanBeFreed() {
diff --git a/paddle/phi/core/memory/allocation/stream_safe_xpu_allocator.h b/paddle/phi/core/memory/allocation/stream_safe_xpu_allocator.h
@@ -37,7 +37,7 @@ class StreamSafeXPUAllocation : public Allocation {
                           XPUStream owning_stream,
                           StreamSafeXPUAllocator *allocator);
 
-  void RecordStream(XPUStream stream);
+  bool RecordStream(XPUStream stream);
   bool CanBeFreed();
   XPUStream GetOwningStream() const;
 
diff --git a/paddle/phi/core/memory/malloc.cc b/paddle/phi/core/memory/malloc.cc
diff --git a/paddle/phi/core/memory/malloc.h b/paddle/phi/core/memory/malloc.h

Original file line number	Diff line number	Diff line change
`@@ -522,19 +522,20 @@ class AllocatorFacadePrivate {`
`522`	`522`	`}`
`523`	`523`	`}`
`524`	`524`
`525`		`- void RecordStream(std::shared_ptr<phi::Allocation> allocation,`
	`525`	`+ bool RecordStream(std::shared_ptr<phi::Allocation> allocation,`
`526`	`526`	`gpuStream_t stream) {`
`527`	`527`	`if (auto stream_safe_cuda_allocation =`
`528`	`528`	`std::dynamic_pointer_cast<StreamSafeCUDAAllocation>(allocation)) {`
`529`		`- stream_safe_cuda_allocation->RecordStream(stream);`
	`529`	`+ return stream_safe_cuda_allocation->RecordStream(stream);`
`530`	`530`	`#ifdef PADDLE_WITH_CUDA`
`531`	`531`	`} else if (auto cuda_malloc_async_allocation =`
`532`	`532`	`std::dynamic_pointer_cast<CUDAMallocAsyncAllocation>(`
`533`	`533`	`allocation)) {`
`534`		`- cuda_malloc_async_allocation->RecordStream(stream);`
	`534`	`+ return cuda_malloc_async_allocation->RecordStream(stream);`
`535`	`535`	`#endif`
`536`	`536`	`} else {`
`537`	`537`	`VLOG(6) << "RecordStream for a non-StreamSafeCUDAAllocation";`
	`538`	`+ return false;`
`538`	`539`	`}`
`539`	`540`	`}`
`540`	`541`
`@@ -659,14 +660,15 @@ class AllocatorFacadePrivate {`
`659`	`660`	`<< place;`
`660`	`661`	`}`
`661`	`662`
`662`		`- void RecordStream(std::shared_ptr<phi::Allocation> allocation,`
	`663`	`+ bool RecordStream(std::shared_ptr<phi::Allocation> allocation,`
`663`	`664`	`XPUStream stream) {`
`664`	`665`	`std::shared_ptr<StreamSafeXPUAllocation> stream_safe_xpu_allocation =`
`665`	`666`	`std::dynamic_pointer_cast<StreamSafeXPUAllocation>(allocation);`
`666`	`667`	`if (stream_safe_xpu_allocation != nullptr) {`
`667`		`- stream_safe_xpu_allocation->RecordStream(stream);`
	`668`	`+ return stream_safe_xpu_allocation->RecordStream(stream);`
`668`	`669`	`} else {`
`669`	`670`	`VLOG(6) << "RecordStream for a non-StreamSafeXPUAllocation";`
	`671`	`+ return false;`
`670`	`672`	`}`
`671`	`673`	`}`
`672`	`674`
`@@ -771,16 +773,17 @@ class AllocatorFacadePrivate {`
`771`	`773`	`<< ") in " << place;`
`772`	`774`	`}`
`773`	`775`
`774`		`- void RecordStream(std::shared_ptr<phi::Allocation> allocation,`
	`776`	`+ bool RecordStream(std::shared_ptr<phi::Allocation> allocation,`
`775`	`777`	`phi::stream::stream_t stream) {`
`776`	`778`	`std::shared_ptr<StreamSafeCustomDeviceAllocation>`
`777`	`779`	`stream_safe_custom_device_allocation =`
`778`	`780`	`std::dynamic_pointer_cast<StreamSafeCustomDeviceAllocation>(`
`779`	`781`	`allocation);`
`780`	`782`	`if (stream_safe_custom_device_allocation != nullptr) {`
`781`		`- stream_safe_custom_device_allocation->RecordStream(stream);`
	`783`	`+ return stream_safe_custom_device_allocation->RecordStream(stream);`
`782`	`784`	`} else {`
`783`	`785`	`VLOG(6) << "RecordStream for a non-StreamSafeCustomDeviceAllocation";`
	`786`	`+ return false;`
`784`	`787`	`}`
`785`	`788`	`}`
`786`	`789`
`@@ -1789,9 +1792,9 @@ uint64_t AllocatorFacade::Release(const phi::GPUPlace& place,`
`1789`	`1792`	`return m->GetAllocator(place, stream)->Release(place);`
`1790`	`1793`	`}`
`1791`	`1794`
`1792`		`-void AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,`
	`1795`	`+bool AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,`
`1793`	`1796`	`gpuStream_t stream) {`
`1794`		`- GetPrivate()->RecordStream(allocation, stream);`
	`1797`	`+ return GetPrivate()->RecordStream(allocation, stream);`
`1795`	`1798`	`}`
`1796`	`1799`
`1797`	`1800`	`void AllocatorFacade::EraseStream(std::shared_ptr<phi::Allocation> allocation,`
`@@ -1913,9 +1916,9 @@ uint64_t AllocatorFacade::Release(const phi::CustomPlace& place,`
`1913`	`1916`	`return m->GetAllocator(place, stream)->Release(place);`
`1914`	`1917`	`}`
`1915`	`1918`
`1916`		`-void AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,`
	`1919`	`+bool AllocatorFacade::RecordStream(std::shared_ptr<phi::Allocation> allocation,`
`1917`	`1920`	`phi::stream::stream_t stream) {`
`1918`		`- GetPrivate()->RecordStream(allocation, stream);`
	`1921`	`+ return GetPrivate()->RecordStream(allocation, stream);`
`1919`	`1922`	`}`
`1920`	`1923`
`1921`	`1924`	`const std::shared_ptr<Allocator>& AllocatorFacade::GetAllocator(`