Fix contians contains, etc (#62324)

co63oc · web-flow · commit 8ae036f0401c · 2024-03-04T11:56:26.000+08:00
diff --git a/paddle/fluid/inference/tensorrt/plugin/preln_groupnorm_act_op_plugin.h b/paddle/fluid/inference/tensorrt/plugin/preln_groupnorm_act_op_plugin.h
@@ -144,7 +144,7 @@ class PrelnGroupnormActPluginDynamic : public DynamicPluginTensorRT {
                        const nvinfer1::DynamicPluginTensorDesc* out,
                        int nbOutputs) TRT_NOEXCEPT override {
     // sizeof(float2) * maxBatchSize * maxNumberOfGroup. float2
-    // contians two buffers for sum and squared sum;
+    // contains two buffers for sum and squared sum;
     ws_ = sizeof(float) * 2 * in[0].max.d[0] * groups_;
   }
 
diff --git a/paddle/fluid/inference/tensorrt/plugin/skip_groupnorm_act_op_plugin.h b/paddle/fluid/inference/tensorrt/plugin/skip_groupnorm_act_op_plugin.h
@@ -139,7 +139,7 @@ class SkipGroupnormActPluginDynamic : public DynamicPluginTensorRT {
                        const nvinfer1::DynamicPluginTensorDesc* out,
                        int nbOutputs) TRT_NOEXCEPT override {
     // sizeof(float2) * maxBatchSize * maxNumberOfGroup. float2
-    // contians two buffers for sum and squared sum;
+    // contains two buffers for sum and squared sum;
     ws_ = sizeof(float) * 2 * in[0].max.d[0] * groups_;
   }
 
diff --git a/paddle/fluid/inference/utils/singleton.h b/paddle/fluid/inference/utils/singleton.h
@@ -35,7 +35,7 @@ struct Singleton {
 };
 
 /*
- * An registor for any type.
+ * An Registry for any type.
  * NOTE not thread-safe.
  */
 template <typename ItemParent>
diff --git a/paddle/fluid/memory/allocation/allocator_facade.cc b/paddle/fluid/memory/allocation/allocator_facade.cc
@@ -232,7 +232,7 @@ class AllocatorFacadePrivate {
 
         // Note(Ruibiao): For GPU multi-stream case without CUDA graph
         // capturing, the 'allocators_' map(place -> Allocator) hold the
-        // StreamSafeCUDAAllocator relate to defaultstream (i.e., the stream
+        // StreamSafeCUDAAllocator relate to default stream (i.e., the stream
         // directly got from DeviceContext), while the 'cuda_allocators_' map
         // (place -> map(stream -> Allocator)) hold the StreamSafeCUDAAllocator
         // relate to non-default stream (i.e., the stream users pass in). The
diff --git a/paddle/fluid/memory/allocation/mmap_allocator.cc b/paddle/fluid/memory/allocation/mmap_allocator.cc
@@ -90,7 +90,7 @@ void AllocateMemoryMap(
   PADDLE_ENFORCE_EQ(ftruncate(fd, size),
                     0,
                     platform::errors::Unavailable(
-                        "Fruncate a file to a specified length failed!"));
+                        "Truncate a file to a specified length failed!"));
 
   if (flags & MAPPED_SHAREDMEM) {
     *map_ptr_ = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
@@ -109,7 +109,7 @@ void AllocateMemoryMap(
     PADDLE_ENFORCE_NE(::close(fd),
                       -1,
                       platform::errors::Unavailable(
-                          "Error closing memory maped file <", filename, ">"));
+                          "Error closing memory mapped file <", filename, ">"));
 
     *fd_ = -1;
   }
@@ -129,10 +129,10 @@ AllocateRefcountedMemoryMapAllocation(std::string filename,
     base_ptr = MemoryMapAllocationPool::Instance().GetById(buffer_id).mmap_ptr_;
     VLOG(4) << "Get a cached shm " << filename;
   }
-  void *aliged_base_ptr =
+  void *aligned_base_ptr =
       static_cast<void *>(static_cast<char *>(base_ptr) + mmap_alignment);
   return std::make_shared<RefcountedMemoryMapAllocation>(
-      aliged_base_ptr, size, filename, flags, fd, buffer_id);
+      aligned_base_ptr, size, filename, flags, fd, buffer_id);
 }
 
 RefcountedMemoryMapAllocation::RefcountedMemoryMapAllocation(
@@ -267,7 +267,7 @@ std::shared_ptr<MemoryMapWriterAllocation> AllocateMemoryMapWriterAllocation(
   PADDLE_ENFORCE_EQ(ftruncate(fd, size),
                     0,
                     platform::errors::Unavailable(
-                        "Fruncate a file to a specified length failed!"));
+                        "Truncate a file to a specified length failed!"));
 
   void *ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
   PADDLE_ENFORCE_NE(ptr,
@@ -337,7 +337,7 @@ MemoryMapAllocationPool *MemoryMapAllocationPool::pool_ = nullptr;
 void MemoryMapAllocationPool::Insert(const MemoryMapInfo &memory_map) {
   std::lock_guard<std::mutex> guard(mtx_);
   memory_map_allocations_.push_back(memory_map);
-  VLOG(4) << this << "Intsert a new shm: " << memory_map.file_name_;
+  VLOG(4) << this << "Insert a new shm: " << memory_map.file_name_;
 }
 
 int MemoryMapAllocationPool::FindFromCache(const int &flag,
diff --git a/paddle/fluid/memory/allocation/stream_safe_xpu_allocator.cc b/paddle/fluid/memory/allocation/stream_safe_xpu_allocator.cc
@@ -175,8 +175,8 @@ uint64_t StreamSafeXPUAllocator::ReleaseImpl(const platform::Place& place) {
 }
 
 void StreamSafeXPUAllocator::ProcessUnfreedAllocations() {
-  // NOTE(Ruibiao): This condition is to reduce lock competion. It does not need
-  // to be thread-safe since here occasional misjudgments are permissible.
+  // NOTE(Ruibiao): This condition is to reduce lock completion. It does not
+  // need to be thread-safe since here occasional misjudgments are permissible.
   if (unfreed_allocations_.empty()) {
     return;
   }
diff --git a/paddle/fluid/memory/allocation/virtual_memory_auto_growth_best_fit_allocator.cc b/paddle/fluid/memory/allocation/virtual_memory_auto_growth_best_fit_allocator.cc
@@ -22,9 +22,8 @@ namespace paddle {
 namespace memory {
 namespace allocation {
 
-bool NeedSplit(size_t block_size, size_t alignment, size_t allock_size) {
-  return block_size > (allock_size * 2) ||
-         (block_size - allock_size) > alignment;
+bool NeedSplit(size_t block_size, size_t alignment, size_t alloc_size) {
+  return block_size > (alloc_size * 2) || (block_size - alloc_size) > alignment;
 }
 
 VirtualMemoryAutoGrowthBestFitAllocator::
diff --git a/paddle/fluid/memory/allocation/virtual_memory_auto_growth_best_fit_allocator.h b/paddle/fluid/memory/allocation/virtual_memory_auto_growth_best_fit_allocator.h
@@ -46,7 +46,7 @@ struct BlockAllocation : public Allocation {
  * Like AutoGrowthBestFitAllocator, VirtualMemoryAutoGrowthBestFitAllocator will
  * gradually apply to GPU for video memory as the model uses more video memory.
  * However, the difference is that VirtualMemoryAutoGrowthBestFitAllocator uses
- * nviaid's virtual memory management technology and obtains the virtual memory
+ * NVIDIA's virtual memory management technology and obtains the virtual memory
  * address. If the video memory applied for twice is continuous, we can combine
  * the two video memories later. This combination can greatly reduce
  * fragmentation.
diff --git a/paddle/fluid/memory/malloc.h b/paddle/fluid/memory/malloc.h
@@ -71,7 +71,7 @@ struct ThrustAllocator {
     place_ = place;
     stream_ = stream;
   }
-  ~ThrustAllocator() { VLOG(2) << "destory allocator"; }
+  ~ThrustAllocator() { VLOG(2) << "destroy allocator"; }
   char* allocate(std::ptrdiff_t num_bytes) {
     VLOG(2) << "allocate " << num_bytes << " bytes";
     auto storage = memory::AllocShared(
diff --git a/paddle/fluid/memory/stats.cc b/paddle/fluid/memory/stats.cc
@@ -36,7 +36,7 @@ class StatRegistry {
     auto it = stat_map_.find(GetStatKey(stat_type, dev_id));
     if (it == stat_map_.end()) {
       PADDLE_THROW(platform::errors::InvalidArgument(
-          "The STAT type \"%s\" for device %d has not been regeistered.",
+          "The STAT type \"%s\" for device %d has not been registered.",
           stat_type.c_str(),
           dev_id));
     }
@@ -171,7 +171,7 @@ int RegisterAllStats() {
   return 0;
 }
 
-UNUSED static int regiester_all_stats = RegisterAllStats();
+UNUSED static int register_all_stats = RegisterAllStats();
 
 }  // namespace memory
 }  // namespace paddle
diff --git a/paddle/fluid/memory/stats.h b/paddle/fluid/memory/stats.h
@@ -42,7 +42,7 @@ struct ThreadLocalStatBase {
 
   friend std::ostream& operator<<(std::ostream& os,
                                   const ThreadLocalStatBase& stat) {
-    os << "{cuerrent : " << stat.current << ", peak : " << stat.peak << "}";
+    os << "{current : " << stat.current << ", peak : " << stat.peak << "}";
     return os;
   }
 };
@@ -136,7 +136,7 @@ void HostMemoryStatUpdate(const std::string& stat_type,
 void LogDeviceMemoryStats(const platform::Place& place,
                           const std::string& op_name);
 
-#define DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, id)              \
+#define DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, id)               \
   case id:                                                          \
     stat = paddle::memory::Stat<                                    \
         paddle::memory::DeviceMemoryStat##item##id>::GetInstance(); \
@@ -146,22 +146,22 @@ void LogDeviceMemoryStats(const platform::Place& place,
   [&] {                                                                       \
     paddle::memory::StatBase* stat = nullptr;                                 \
     switch (id) {                                                             \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 0);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 1);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 2);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 3);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 4);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 5);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 6);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 7);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 8);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 9);                          \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 10);                         \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 11);                         \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 12);                         \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 13);                         \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 14);                         \
-      DEVICE_MEMORY_STAT_FUNC_SWITHCH_CASE(item, 15);                         \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 0);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 1);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 2);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 3);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 4);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 5);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 6);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 7);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 8);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 9);                           \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 10);                          \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 11);                          \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 12);                          \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 13);                          \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 14);                          \
+      DEVICE_MEMORY_STAT_FUNC_SWITCH_CASE(item, 15);                          \
       default:                                                                \
         PADDLE_THROW(paddle::platform::errors::OutOfRange(                    \
             "Only support device id between [0, 15] for device memory stats," \
diff --git a/paddle/fluid/operators/cinn/cinn_launch_context.cc b/paddle/fluid/operators/cinn/cinn_launch_context.cc
@@ -412,10 +412,10 @@ std::unique_ptr<framework::ProgramDesc> CinnLaunchContext::BuildCompiledProgram(
 
   // build a map that links the name of a Paddle variable to its VarDesc
   const std::unordered_set<framework::ir::Node*>& nodes = graph.Nodes();
-  std::unordered_map<std::string, framework::VarDesc*> original_vardescs;
+  std::unordered_map<std::string, framework::VarDesc*> original_var_descs;
   for (auto* node : nodes) {
     if (node->IsVar() && node->Var()) {
-      original_vardescs.emplace(node->Name(), node->Var());
+      original_var_descs.emplace(node->Name(), node->Var());
     }
   }
 
@@ -433,8 +433,8 @@ std::unique_ptr<framework::ProgramDesc> CinnLaunchContext::BuildCompiledProgram(
     framework::VarDesc* var_desc = block->Var(var_name);
     var_desc->SetType(framework::proto::VarType::LOD_TENSOR);
 
-    auto res = original_vardescs.find(var_name);
-    if (res != original_vardescs.end()) {
+    auto res = original_var_descs.find(var_name);
+    if (res != original_var_descs.end()) {
       auto* ori_desc = res->second;
       var_desc->SetPersistable(ori_desc->Persistable());
       var_desc->SetIsParameter(ori_desc->IsParameter());

Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ class PrelnGroupnormActPluginDynamic : public DynamicPluginTensorRT {`
`144`	`144`	`const nvinfer1::DynamicPluginTensorDesc* out,`
`145`	`145`	`int nbOutputs) TRT_NOEXCEPT override {`
`146`	`146`	`// sizeof(float2) * maxBatchSize * maxNumberOfGroup. float2`
`147`		`- // contians two buffers for sum and squared sum;`
	`147`	`+ // contains two buffers for sum and squared sum;`
`148`	`148`	`ws_ = sizeof(float) * 2 * in[0].max.d[0] * groups_;`
`149`	`149`	`}`
`150`	`150`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ class SkipGroupnormActPluginDynamic : public DynamicPluginTensorRT {`
`139`	`139`	`const nvinfer1::DynamicPluginTensorDesc* out,`
`140`	`140`	`int nbOutputs) TRT_NOEXCEPT override {`
`141`	`141`	`// sizeof(float2) * maxBatchSize * maxNumberOfGroup. float2`
`142`		`- // contians two buffers for sum and squared sum;`
	`142`	`+ // contains two buffers for sum and squared sum;`
`143`	`143`	`ws_ = sizeof(float) * 2 * in[0].max.d[0] * groups_;`
`144`	`144`	`}`
`145`	`145`
Original file line number	Diff line number	Diff line change
`@@ -175,8 +175,8 @@ uint64_t StreamSafeXPUAllocator::ReleaseImpl(const platform::Place& place) {`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`void StreamSafeXPUAllocator::ProcessUnfreedAllocations() {`
`178`		`- // NOTE(Ruibiao): This condition is to reduce lock competion. It does not need`
`179`		`- // to be thread-safe since here occasional misjudgments are permissible.`
	`178`	`+ // NOTE(Ruibiao): This condition is to reduce lock completion. It does not`
	`179`	`+ // need to be thread-safe since here occasional misjudgments are permissible.`
`180`	`180`	`if (unfreed_allocations_.empty()) {`
`181`	`181`	`return;`
`182`	`182`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ struct ThrustAllocator {`
`71`	`71`	`place_ = place;`
`72`	`72`	`stream_ = stream;`
`73`	`73`	`}`
`74`		`- ~ThrustAllocator() { VLOG(2) << "destory allocator"; }`
	`74`	`+ ~ThrustAllocator() { VLOG(2) << "destroy allocator"; }`
`75`	`75`	`char* allocate(std::ptrdiff_t num_bytes) {`
`76`	`76`	`VLOG(2) << "allocate " << num_bytes << " bytes";`
`77`	`77`	`auto storage = memory::AllocShared(`