google · ckennelly · Oct 25, 2020
diff --git a/tcmalloc/central_freelist.h b/tcmalloc/central_freelist.h
@@ -65,9 +65,7 @@ class CentralFreeList {
   size_t OverheadBytes();
 
   // My size class.
-  size_t size_class() const {
-    return size_class_;
-  }
+  size_t size_class() const { return size_class_; }
 
   SpanStats GetSpanStats() const;
 

diff --git a/tcmalloc/central_freelist_test.cc b/tcmalloc/central_freelist_test.cc
@@ -16,9 +16,9 @@
 
 #include <algorithm>
 
+#include "absl/random/random.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/random/random.h"
 #include "tcmalloc/common.h"
 #include "tcmalloc/static_vars.h"
 

diff --git a/tcmalloc/common.h b/tcmalloc/common.h
@@ -337,7 +337,7 @@ class SizeMap {
  public:
   // Constructor should do nothing since we rely on explicit Init()
   // call, which may or may not be called before the constructor runs.
-  SizeMap() { }
+  SizeMap() {}
 
   // Initialize the mapping arrays
   void Init();

diff --git a/tcmalloc/cpu_cache.cc b/tcmalloc/cpu_cache.cc
@@ -633,9 +633,7 @@ static void ActivatePerCPUCaches() {
 
 class PerCPUInitializer {
  public:
-  PerCPUInitializer() {
-   ActivatePerCPUCaches();
-  }
+  PerCPUInitializer() { ActivatePerCPUCaches(); }
 };
 static PerCPUInitializer module_enter_exit;
 

diff --git a/tcmalloc/cpu_cache.h b/tcmalloc/cpu_cache.h
@@ -34,7 +34,6 @@
 
 namespace tcmalloc {
 
-
 class CPUCache {
  public:
   enum class ActivationMode {
@@ -258,5 +257,5 @@ inline bool UsePerCpuCache() {
   return false;
 }
 
-};  // namespace tcmalloc
+};      // namespace tcmalloc
 #endif  // TCMALLOC_CPU_CACHE_H_
diff --git a/tcmalloc/guarded_page_allocator.cc b/tcmalloc/guarded_page_allocator.cc
@@ -426,7 +426,6 @@ static void RecordTestFailure(absl::string_view error) {
 //
 // error contains the type of error to record.
 static void RecordCrash(absl::string_view error) {
-
   RecordBazelWarning(error);
   RecordTestFailure(error);
 }
@@ -461,8 +460,7 @@ static void SegvHandler(int signo, siginfo_t *info, void *context) {
   std::tie(offset, size) =
       Static::guardedpage_allocator().GetAllocationOffsetAndSize(fault);
 
-  Log(kLog, __FILE__, __LINE__,
-      "*** GWP-ASan has detected a memory error ***");
+  Log(kLog, __FILE__, __LINE__, "*** GWP-ASan has detected a memory error ***");
   Log(kLog, __FILE__, __LINE__, ">>> Access at offset", offset,
       "into buffer of length", size);
   Log(kLog, __FILE__, __LINE__,

diff --git a/tcmalloc/guarded_page_allocator_benchmark.cc b/tcmalloc/guarded_page_allocator_benchmark.cc
@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "tcmalloc/guarded_page_allocator.h"
-
 #include <unistd.h>
 
-#include "benchmark/benchmark.h"
 #include "absl/base/internal/spinlock.h"
+#include "benchmark/benchmark.h"
+#include "tcmalloc/guarded_page_allocator.h"
 #include "tcmalloc/internal/logging.h"
 
 namespace tcmalloc {

diff --git a/tcmalloc/guarded_page_allocator_test.cc b/tcmalloc/guarded_page_allocator_test.cc
@@ -25,15 +25,15 @@
 #include <thread>  // NOLINT(build/c++11)
 #include <vector>
 
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "absl/base/internal/spinlock.h"
 #include "absl/base/internal/sysinfo.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/common.h"
 #include "tcmalloc/internal/logging.h"
 #include "tcmalloc/static_vars.h"

diff --git a/tcmalloc/huge_address_map_test.cc b/tcmalloc/huge_address_map_test.cc
@@ -15,6 +15,7 @@
 #include "tcmalloc/huge_address_map.h"
 
 #include <stdlib.h>
+
 #include <vector>
 
 #include "gmock/gmock.h"

diff --git a/tcmalloc/huge_allocator_test.cc b/tcmalloc/huge_allocator_test.cc
@@ -23,11 +23,11 @@
 #include <utility>
 #include <vector>
 
-#include "gtest/gtest.h"
 #include "absl/base/internal/cycleclock.h"
 #include "absl/random/random.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/logging.h"
 

diff --git a/tcmalloc/huge_cache_test.cc b/tcmalloc/huge_cache_test.cc
@@ -23,14 +23,14 @@
 #include <utility>
 #include <vector>
 
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "absl/base/internal/cycleclock.h"
 #include "absl/memory/memory.h"
 #include "absl/random/random.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/logging.h"
 #include "tcmalloc/stats.h"
@@ -514,7 +514,6 @@ TEST_F(HugeCacheTest, Usage) {
 }
 
 class MinMaxTrackerTest : public testing::Test {
-
  protected:
   void Advance(absl::Duration d) {
     clock_ += absl::ToDoubleSeconds(d) * GetFakeClockFrequency();

diff --git a/tcmalloc/huge_page_aware_allocator.cc b/tcmalloc/huge_page_aware_allocator.cc
@@ -215,7 +215,8 @@ Span *HugePageAwareAllocator::AllocLarge(Length n, bool *from_released) {
   // typically faster and usually more space efficient, but it's sometimes
   // catastrophic.
   //
-  // See https://github.com/google/tcmalloc/tree/master/docs/regions-are-not-optional.md
+  // See
+  // https://github.com/google/tcmalloc/tree/master/docs/regions-are-not-optional.md
   //
   // So test directly if we're in the bad case--almost no binaries are.
   // If not, just fall back to direct allocation (and hope we do hit that case!)

diff --git a/tcmalloc/huge_page_aware_allocator_test.cc b/tcmalloc/huge_page_aware_allocator_test.cc
@@ -29,9 +29,6 @@
 #include <utility>
 #include <vector>
 
-#include "benchmark/benchmark.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "absl/base/attributes.h"
 #include "absl/base/const_init.h"
 #include "absl/base/internal/spinlock.h"
@@ -45,6 +42,9 @@
 #include "absl/synchronization/barrier.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/time.h"
+#include "benchmark/benchmark.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/common.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/logging.h"
@@ -169,7 +169,8 @@ class HugePageAwareAllocatorTest : public ::testing::Test {
     // TODO(b/128521238): scalable RNG
     absl::base_internal::SpinLockHolder h(&lock_);
     if (absl::Bernoulli(rng_, 1.0 / 1000)) {
-      Length n = Length(1024) * (1 + absl::LogUniform<int32_t>(rng_, 0, (1 << 8) - 1));
+      Length n =
+          Length(1024) * (1 + absl::LogUniform<int32_t>(rng_, 0, (1 << 8) - 1));
       n += Length(absl::Uniform<int32_t>(rng_, 0, 1024));
       return n;
     }

diff --git a/tcmalloc/huge_page_filler.h b/tcmalloc/huge_page_filler.h
@@ -1871,7 +1871,7 @@ inline void HugePageFiller<TrackerType>::PrintInPbtxt(PbtxtRegion *hpaa) const {
   hpaa->PrintI64(
       "filler_hugepageable_used_bytes",
       static_cast<uint64_t>(hugepage_frac() *
-                          static_cast<double>(allocated_.in_bytes())));
+                            static_cast<double>(allocated_.in_bytes())));
   hpaa->PrintI64("filler_num_pages_subreleased",
                  subrelease_stats_.total_pages_subreleased.raw_num());
   hpaa->PrintI64("filler_num_hugepages_broken",

diff --git a/tcmalloc/huge_page_filler_test.cc b/tcmalloc/huge_page_filler_test.cc
@@ -28,9 +28,6 @@
 #include <utility>
 #include <vector>
 
-#include "benchmark/benchmark.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "absl/algorithm/container.h"
 #include "absl/base/internal/sysinfo.h"
 #include "absl/base/thread_annotations.h"
@@ -46,6 +43,9 @@
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "benchmark/benchmark.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/common.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/logging.h"
@@ -684,9 +684,7 @@ class FillerTest : public testing::TestWithParam<FillerPartialRerelease> {
     ResetClock();
   }
 
-  ~FillerTest() override {
-    EXPECT_EQ(NHugePages(0), filler_.size());
-  }
+  ~FillerTest() override { EXPECT_EQ(NHugePages(0), filler_.size()); }
 
   struct PAlloc {
     FakeTracker *pt;

diff --git a/tcmalloc/huge_region_test.cc b/tcmalloc/huge_region_test.cc
@@ -21,11 +21,11 @@
 #include <memory>
 #include <vector>
 
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "absl/random/random.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/common.h"
 #include "tcmalloc/huge_pages.h"
 #include "tcmalloc/internal/logging.h"

diff --git a/tcmalloc/internal/bits_test.cc b/tcmalloc/internal/bits_test.cc
@@ -18,9 +18,9 @@
 #include <limits>
 #include <memory>
 
+#include "absl/random/random.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "absl/random/random.h"
 
 namespace tcmalloc {
 namespace tcmalloc_internal {

diff --git a/tcmalloc/internal/environment.cc b/tcmalloc/internal/environment.cc
@@ -24,7 +24,7 @@ namespace tcmalloc_internal {
 // return a const pointer into it.
 // e.g. { "SHELL=/bin/bash", "MY_ENV_VAR=1", "" }
 extern "C" char **environ;
-const char* thread_safe_getenv(const char *env_var) {
+const char *thread_safe_getenv(const char *env_var) {
   int var_len = strlen(env_var);
 
   char **envv = environ;

diff --git a/tcmalloc/internal/environment.h b/tcmalloc/internal/environment.h
@@ -30,7 +30,7 @@ namespace tcmalloc_internal {
 // from thread_safe_getenv() may be safely queried in a multi-threaded context.
 // If you have explicit synchronization with changes environment variables then
 // any copies of the returned pointer must be invalidated across modification.
-const char* thread_safe_getenv(const char *env_var);
+const char* thread_safe_getenv(const char* env_var);
 
 }  // namespace tcmalloc_internal
 }  // namespace tcmalloc

diff --git a/tcmalloc/internal/linked_list.h b/tcmalloc/internal/linked_list.h
@@ -28,11 +28,11 @@
 namespace tcmalloc {
 
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE void *SLL_Next(void *t) {
-  return *(reinterpret_cast<void**>(t));
+  return *(reinterpret_cast<void **>(t));
 }
 
 inline void ABSL_ATTRIBUTE_ALWAYS_INLINE SLL_SetNext(void *t, void *n) {
-  *(reinterpret_cast<void**>(t)) = n;
+  *(reinterpret_cast<void **>(t)) = n;
 }
 
 inline void ABSL_ATTRIBUTE_ALWAYS_INLINE SLL_Push(void **list, void *element) {

diff --git a/tcmalloc/internal/linked_list_test.cc b/tcmalloc/internal/linked_list_test.cc
@@ -19,10 +19,10 @@
 #include <algorithm>
 #include <vector>
 
-#include "benchmark/benchmark.h"
-#include "gtest/gtest.h"
 #include "absl/container/node_hash_set.h"
 #include "absl/random/random.h"
+#include "benchmark/benchmark.h"
+#include "gtest/gtest.h"
 #include "tcmalloc/internal/mock_span.h"
 
 namespace tcmalloc {

diff --git a/tcmalloc/internal/logging.cc b/tcmalloc/internal/logging.cc
@@ -38,7 +38,7 @@ ABSL_CONST_INIT static absl::base_internal::SpinLock crash_lock(
 static bool crashed = false;
 
 static const size_t kStatsBufferSize = 16 << 10;
-static char stats_buffer[kStatsBufferSize] = { 0 };
+static char stats_buffer[kStatsBufferSize] = {0};
 
 namespace tcmalloc {
 
@@ -67,14 +67,9 @@ static Logger FormatLog(bool with_stack, const char* filename, int line,
   Logger state;
   state.p_ = state.buf_;
   state.end_ = state.buf_ + sizeof(state.buf_);
-  state.AddStr(filename, strlen(filename))
-      && state.AddStr(":", 1)
-      && state.AddNum(line, 10)
-      && state.AddStr("]", 1)
-      && state.Add(a)
-      && state.Add(b)
-      && state.Add(c)
-      && state.Add(d);
+  state.AddStr(filename, strlen(filename)) && state.AddStr(":", 1) &&
+      state.AddNum(line, 10) && state.AddStr("]", 1) && state.Add(a) &&
+      state.Add(b) && state.Add(c) && state.Add(d);
 
   if (with_stack) {
     state.trace.depth =