Fix MemEvenRecorder MemEventRecorder (#62537)

co63oc · web-flow · commit 7fd1722f21d7 · 2024-03-08T10:41:05.000+08:00
diff --git a/paddle/fluid/platform/profiler.cc b/paddle/fluid/platform/profiler.cc
@@ -56,7 +56,7 @@ std::mutex phi::ProfilerHelper::g_all_mem_event_lists_mutex;
 namespace paddle {
 namespace platform {
 
-MemEvenRecorder MemEvenRecorder::recorder;
+MemEventRecorder MemEventRecorder::recorder;
 
 RecordInstantEvent::RecordInstantEvent(const char *name,
                                        TracerEventType type,
@@ -214,14 +214,14 @@ RecordMemEvent::RecordMemEvent(const void *ptr,
             RecordMemEvent::size_cache["gpu"][place.GetDeviceId()][3];
       }
     }
-    platform::MemEvenRecorder::Instance().PushMemRecord(ptr,
-                                                        place,
-                                                        size,
-                                                        type,
-                                                        current_allocated,
-                                                        current_reserved,
-                                                        peak_allocated,
-                                                        peak_reserved);
+    platform::MemEventRecorder::Instance().PushMemRecord(ptr,
+                                                         place,
+                                                         size,
+                                                         type,
+                                                         current_allocated,
+                                                         current_reserved,
+                                                         peak_allocated,
+                                                         peak_reserved);
   } else if (type == TracerMemEventType::ReservedAllocate) {
     uint64_t current_reserved = 0;
     uint64_t peak_reserved = 0;
@@ -297,14 +297,14 @@ RecordMemEvent::RecordMemEvent(const void *ptr,
             RecordMemEvent::size_cache["gpu"][place.GetDeviceId()][2];
       }
     }
-    platform::MemEvenRecorder::Instance().PushMemRecord(ptr,
-                                                        place,
-                                                        size,
-                                                        type,
-                                                        current_allocated,
-                                                        current_reserved,
-                                                        peak_allocated,
-                                                        peak_reserved);
+    platform::MemEventRecorder::Instance().PushMemRecord(ptr,
+                                                         place,
+                                                         size,
+                                                         type,
+                                                         current_allocated,
+                                                         current_reserved,
+                                                         peak_allocated,
+                                                         peak_reserved);
   } else if (type == TracerMemEventType::Free) {
     uint64_t current_allocated = 0;
     uint64_t peak_allocated = 0;
@@ -380,14 +380,14 @@ RecordMemEvent::RecordMemEvent(const void *ptr,
             RecordMemEvent::size_cache["gpu"][place.GetDeviceId()][3];
       }
     }
-    platform::MemEvenRecorder::Instance().PopMemRecord(ptr,
-                                                       place,
-                                                       size,
-                                                       type,
-                                                       current_allocated,
-                                                       current_reserved,
-                                                       peak_allocated,
-                                                       peak_reserved);
+    platform::MemEventRecorder::Instance().PopMemRecord(ptr,
+                                                        place,
+                                                        size,
+                                                        type,
+                                                        current_allocated,
+                                                        current_reserved,
+                                                        peak_allocated,
+                                                        peak_reserved);
   } else if (type == TracerMemEventType::ReservedFree) {
     uint64_t current_reserved = 0;
     uint64_t peak_reserved = 0;
@@ -463,20 +463,20 @@ RecordMemEvent::RecordMemEvent(const void *ptr,
             RecordMemEvent::size_cache["gpu"][place.GetDeviceId()][2];
       }
     }
-    platform::MemEvenRecorder::Instance().PopMemRecord(ptr,
-                                                       place,
-                                                       size,
-                                                       type,
-                                                       current_allocated,
-                                                       current_reserved,
-                                                       peak_allocated,
-                                                       peak_reserved);
+    platform::MemEventRecorder::Instance().PopMemRecord(ptr,
+                                                        place,
+                                                        size,
+                                                        type,
+                                                        current_allocated,
+                                                        current_reserved,
+                                                        peak_allocated,
+                                                        peak_reserved);
   }
 }
 
-void MemEvenRecorder::PushMemRecord(const void *ptr,
-                                    const Place &place,
-                                    size_t size) {
+void MemEventRecorder::PushMemRecord(const void *ptr,
+                                     const Place &place,
+                                     size_t size) {
   if (phi::ProfilerHelper::g_state == ProfilerState::kDisabled) {
     return;
   }
@@ -487,17 +487,17 @@ void MemEvenRecorder::PushMemRecord(const void *ptr,
                     platform::errors::InvalidArgument(
                         "The Place can't exist in the stage of PushMemRecord"));
   events.emplace(
-      ptr, std::make_unique<MemEvenRecorder::RecordMemEvent>(place, size));
+      ptr, std::make_unique<MemEventRecorder::RecordMemEvent>(place, size));
 }
 
-void MemEvenRecorder::PushMemRecord(const void *ptr,
-                                    const Place &place,
-                                    size_t size,
-                                    TracerMemEventType type,
-                                    uint64_t current_allocated,
-                                    uint64_t current_reserved,
-                                    uint64_t peak_allocated,
-                                    uint64_t peak_reserved) {
+void MemEventRecorder::PushMemRecord(const void *ptr,
+                                     const Place &place,
+                                     size_t size,
+                                     TracerMemEventType type,
+                                     uint64_t current_allocated,
+                                     uint64_t current_reserved,
+                                     uint64_t peak_allocated,
+                                     uint64_t peak_reserved) {
   std::lock_guard<std::mutex> guard(mtx_);
   if (FLAGS_enable_host_event_recorder_hook) {  // new MemRecord
     HostEventRecorder<CommonMemEvent>::GetInstance().RecordEvent(
@@ -523,10 +523,10 @@ void MemEvenRecorder::PushMemRecord(const void *ptr,
                     platform::errors::InvalidArgument(
                         "The Place can't exist in the stage of PushMemRecord"));
   events.emplace(
-      ptr, std::make_unique<MemEvenRecorder::RecordMemEvent>(place, size));
+      ptr, std::make_unique<MemEventRecorder::RecordMemEvent>(place, size));
 }
 
-void MemEvenRecorder::PopMemRecord(const void *ptr, const Place &place) {
+void MemEventRecorder::PopMemRecord(const void *ptr, const Place &place) {
   if (phi::ProfilerHelper::g_state == ProfilerState::kDisabled) {
     return;
   }
@@ -539,14 +539,14 @@ void MemEvenRecorder::PopMemRecord(const void *ptr, const Place &place) {
   }
 }
 
-void MemEvenRecorder::PopMemRecord(const void *ptr,
-                                   const Place &place,
-                                   size_t size,
-                                   TracerMemEventType type,
-                                   uint64_t current_allocated,
-                                   uint64_t current_reserved,
-                                   uint64_t peak_allocated,
-                                   uint64_t peak_reserved) {
+void MemEventRecorder::PopMemRecord(const void *ptr,
+                                    const Place &place,
+                                    size_t size,
+                                    TracerMemEventType type,
+                                    uint64_t current_allocated,
+                                    uint64_t current_reserved,
+                                    uint64_t peak_allocated,
+                                    uint64_t peak_reserved) {
   std::lock_guard<std::mutex> guard(mtx_);
   if (FLAGS_enable_host_event_recorder_hook) {  // new MemRecord
     HostEventRecorder<CommonMemEvent>::GetInstance().RecordEvent(
@@ -574,21 +574,21 @@ void MemEvenRecorder::PopMemRecord(const void *ptr,
   }
 }
 
-void MemEvenRecorder::Flush() {
+void MemEventRecorder::Flush() {
   std::lock_guard<std::mutex> guard(mtx_);
   address_memevent_.clear();
 }
 
-MemEvenRecorder::RecordMemEvent::RecordMemEvent(const Place &place,
-                                                size_t bytes)
+MemEventRecorder::RecordMemEvent::RecordMemEvent(const Place &place,
+                                                 size_t bytes)
     : place_(place),
       bytes_(bytes),
       start_ns_(PosixInNsec()),
       alloc_in_(phi::CurAnnotationName()) {
   PushMemEvent(start_ns_, end_ns_, bytes_, place_, alloc_in_);
 }
 
-MemEvenRecorder::RecordMemEvent::~RecordMemEvent() {  // NOLINT
+MemEventRecorder::RecordMemEvent::~RecordMemEvent() {  // NOLINT
   phi::DeviceTracer *tracer = phi::GetDeviceTracer();
   end_ns_ = PosixInNsec();
 
@@ -701,7 +701,7 @@ void EnableProfiler(ProfilerState state) {
 void ResetProfiler() {
   SynchronizeAllDevice();
   phi::GetDeviceTracer()->Reset();
-  MemEvenRecorder::Instance().Flush();
+  MemEventRecorder::Instance().Flush();
   std::lock_guard<std::mutex> guard(
       phi::ProfilerHelper::g_all_event_lists_mutex);
   for (auto &all_event_list : phi::ProfilerHelper::g_all_event_lists) {
@@ -720,7 +720,7 @@ void DisableProfiler(EventSortingKey sorted_key,
                      const std::string &profile_path) {
   SynchronizeAllDevice();
   auto thr_events = DockHostEventRecorderHostPart();
-  MemEvenRecorder::Instance().Flush();
+  MemEventRecorder::Instance().Flush();
 
   std::lock_guard<std::mutex> l(profiler_mu);
   if (phi::ProfilerHelper::g_state == ProfilerState::kDisabled) return;
@@ -755,7 +755,7 @@ void CompleteProfilerEvents(phi::proto::Profile *tracer_profile,
                             std::vector<std::vector<MemEvent>> *mem_events) {
   SynchronizeAllDevice();
   auto thr_events = DockHostEventRecorderHostPart();
-  MemEvenRecorder::Instance().Flush();
+  MemEventRecorder::Instance().Flush();
   std::lock_guard<std::mutex> l(profiler_mu);
   if (phi::ProfilerHelper::g_state == ProfilerState::kDisabled) return;
   // Mark the profiling stop.
diff --git a/paddle/fluid/platform/profiler.h b/paddle/fluid/platform/profiler.h
@@ -69,7 +69,7 @@ enum class EventSortingKey {
   kGPUTime
 };
 
-struct MemoryProfierReport {
+struct MemoryProfilerReport {
   size_t alloc_times{0};
   size_t alloc_size{0};
   size_t free_times{0};
@@ -101,7 +101,7 @@ struct OverHead {
   std::vector<EventItem> sub_memcpy_items;
 };
 
-struct MemEvenRecorder {
+struct MemEventRecorder {
  public:
   void PushMemRecord(const void* ptr, const Place& place, size_t size);
   void PopMemRecord(const void* ptr, const Place& place);
@@ -122,7 +122,7 @@ struct MemEvenRecorder {
                     uint64_t peak_allocated,
                     uint64_t peak_reserved);
   void Flush();
-  static MemEvenRecorder& Instance() { return recorder; }
+  static MemEventRecorder& Instance() { return recorder; }
 
  private:
   struct RecordMemEvent {
@@ -137,13 +137,13 @@ struct MemEvenRecorder {
     std::string free_in_;
   };
 
-  static MemEvenRecorder recorder;
+  static MemEventRecorder recorder;
   std::map<Place,
            std::unordered_map<const void*, std::unique_ptr<RecordMemEvent>>>
       address_memevent_;
   std::mutex mtx_;
-  MemEvenRecorder() {}
-  DISABLE_COPY_AND_ASSIGN(MemEvenRecorder);
+  MemEventRecorder() {}
+  DISABLE_COPY_AND_ASSIGN(MemEventRecorder);
 };
 
 struct RecordBlock {
diff --git a/paddle/fluid/platform/profiler_helper.h b/paddle/fluid/platform/profiler_helper.h
@@ -132,7 +132,7 @@ static double ToMegaBytes(size_t bytes) {
 
 // Print results
 void PrintMemProfiler(
-    const std::map<Place, std::unordered_map<std::string, MemoryProfierReport>>
+    const std::map<Place, std::unordered_map<std::string, MemoryProfilerReport>>
         &annotation_report,
     const size_t name_width,
     const size_t data_width) {
@@ -200,7 +200,7 @@ void PrintMemProfiler(
 void ParseMemEvents(const std::vector<std::vector<MemEvent>> &events) {
   if (phi::ProfilerHelper::g_state == ProfilerState::kDisabled) return;
   // place, annotation, alloc times,  alloc size
-  std::map<Place, std::unordered_map<std::string, MemoryProfierReport>>
+  std::map<Place, std::unordered_map<std::string, MemoryProfilerReport>>
       annotation_report;
 
   for (auto &tmp : events) {
