Strongly type alignment value in profile samples.

PiperOrigin-RevId: 819260208
Change-Id: Id9c7e03e5a45c4ca8656344b2823315d6e8ac27c

Author: ckennelly

tcmalloc/deallocation_profiler.cc

@@ -22,6 +22,7 @@
 #include <functional>
 #include <limits>
 #include <memory>
+#include <new>
 #include <optional>
 #include <type_traits>
 #include <utility>
@@ -671,7 +672,12 @@ void DeallocationProfiler::DeallocationStackTraceTable::Iterate(
       const auto bucketize = internal::LifetimeNsToBucketedDuration;
       Profile::Sample sample;
       sample.sum = sum, sample.requested_size = k.alloc.requested_size,
-      sample.requested_alignment = k.alloc.requested_alignment,
+      // TODO(b/404341539): Propagate type to StackTrace.
+          sample.requested_alignment =
+              k.alloc.requested_alignment > 0
+                  ? std::make_optional(static_cast<std::align_val_t>(
+                        k.alloc.requested_alignment))
+                  : std::nullopt,
       sample.allocated_size = allocated_size, sample.profile_id = pair_id++,
       // Set the is_censored flag so that when we create a proto
       // sample later we can treat the *_lifetime accordingly.

tcmalloc/internal/profile_builder.cc

@@ -584,7 +584,10 @@ static absl::Status MakeLifetimeProfileProto(const tcmalloc::Profile& profile,
     // The following three fields are common across profiles.
     add_positive_label(bytes_id, bytes_id, entry.allocated_size);
     add_positive_label(request_id, bytes_id, entry.requested_size);
-    add_positive_label(alignment_id, bytes_id, entry.requested_alignment);
+    if (entry.requested_alignment.has_value()) {
+      add_positive_label(alignment_id, bytes_id,
+                         static_cast<size_t>(*entry.requested_alignment));
+    }
 
     // The following fields are specific to lifetime (deallocation) profiler.
     add_positive_label(callstack_pair_id, count_id, entry.profile_id);
@@ -792,7 +795,10 @@ absl::StatusOr<std::unique_ptr<perftools::profiles::Profile>> MakeProfileProto(
 
     add_positive_label(bytes_id, bytes_id, entry.allocated_size);
     add_positive_label(request_id, bytes_id, entry.requested_size);
-    add_positive_label(alignment_id, bytes_id, entry.requested_alignment);
+    if (entry.requested_alignment.has_value()) {
+      add_positive_label(alignment_id, bytes_id,
+                         static_cast<size_t>(*entry.requested_alignment));
+    }
     add_positive_label(size_returning_id, 0, entry.requested_size_returning);
     add_positive_label(stale_scan_period_id, seconds_id,
                        data.stale_scan_period.value_or(0));

tcmalloc/internal/profile_builder_test.cc

@@ -25,6 +25,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
+#include <new>
 #include <optional>
 #include <string>
 #include <tuple>
@@ -336,7 +337,7 @@ perftools::profiles::Profile MakeTestProfile(
     sample.sum = 1234;
     sample.count = 2;
     sample.requested_size = 2;
-    sample.requested_alignment = 4;
+    sample.requested_alignment = std::align_val_t{4};
     sample.requested_size_returning = true;
     sample.allocated_size = 16;
 
@@ -385,7 +386,7 @@ perftools::profiles::Profile MakeTestProfile(
     sample.sum = 2345;
     sample.count = 5;
     sample.requested_size = 4;
-    sample.requested_alignment = 0;
+    sample.requested_alignment = std::nullopt;
     sample.requested_size_returning = false;
     sample.allocated_size = 8;
     sample.span_start_address = ptr1;
@@ -427,7 +428,7 @@ perftools::profiles::Profile MakeTestProfile(
     sample.sum = 2345;
     sample.count = 8;
     sample.requested_size = 16;
-    sample.requested_alignment = 0;
+    sample.requested_alignment = std::nullopt;
     sample.requested_size_returning = true;
     sample.allocated_size = 16;
     // This stack is mostly artificial, but we include a real symbol from the
@@ -451,7 +452,7 @@ perftools::profiles::Profile MakeTestProfile(
     sample.sum = 1235;
     sample.count = 2;
     sample.requested_size = 2;
-    sample.requested_alignment = 4;
+    sample.requested_alignment = std::align_val_t{4};
     sample.requested_size_returning = true;
     sample.allocated_size = 16;
 
@@ -729,7 +730,7 @@ TEST(ProfileBuilderTest, PeakHeapProfile) {
     sample.sum = 1234;
     sample.count = 2;
     sample.requested_size = 2;
-    sample.requested_alignment = 4;
+    sample.requested_alignment = std::align_val_t{4};
     sample.requested_size_returning = true;
     sample.allocated_size = 16;
 
@@ -749,7 +750,7 @@ TEST(ProfileBuilderTest, PeakHeapProfile) {
     sample.sum = 2345;
     sample.count = 5;
     sample.requested_size = 4;
-    sample.requested_alignment = 0;
+    sample.requested_alignment = std::nullopt;
     sample.requested_size_returning = false;
     sample.allocated_size = 8;
 
@@ -814,7 +815,7 @@ TEST(ProfileBuilderTest, LifetimeProfile) {
         .count = 2,
         // Common information we retain in the lifetime profile.
         .requested_size = 2,
-        .requested_alignment = 4,
+        .requested_alignment = std::align_val_t{4},
         .allocated_size = 16,
         // Lifetime specific information in each sample.
         .profile_id = 33,

tcmalloc/malloc_extension.h

@@ -148,7 +148,7 @@ class Profile final {
     size_t requested_size;
     // The requested alignment if specified.  malloc() implicitly aligns to
     // alignof(std::max_align_t) and this value is used.
-    size_t requested_alignment;
+    std::optional<std::align_val_t> requested_alignment;
     // The actual size allocated considering size, implicit/explicit alignment,
     // GWP-ASan.
     size_t allocated_size;

tcmalloc/profile_test.cc

@@ -167,23 +167,23 @@ TEST(AllocationSampleTest, SampleAccuracy) {
   // (object size, object alignment, keep objects)
   struct Requests {
     size_t size;
-    size_t alignment;
+    std::optional<std::align_val_t> alignment;
     std::optional<tcmalloc::hot_cold_t> hot_cold;
     bool expected_hot;
     bool keep;
     // objects we don't delete as we go
     void* list = nullptr;
   };
   std::vector<Requests> sizes = {
-      {8, 0, std::nullopt, true, false},
-      {16, 16, std::nullopt, true, true},
-      {1024, 0, std::nullopt, true, false},
-      {64 * 1024, 64, std::nullopt, true, false},
-      {512 * 1024, 0, std::nullopt, true, true},
-      {1024 * 1024, 128, std::nullopt, true, true},
-      {32, 0, tcmalloc::hot_cold_t{0}, false, true},
-      {64, 0, tcmalloc::hot_cold_t{255}, true, true},
-      {8192, 0, tcmalloc::hot_cold_t{0}, false, true},
+      {8, std::nullopt, std::nullopt, true, false},
+      {16, std::align_val_t{16}, std::nullopt, true, true},
+      {1024, std::nullopt, std::nullopt, true, false},
+      {64 * 1024, std::align_val_t{64}, std::nullopt, true, false},
+      {512 * 1024, std::nullopt, std::nullopt, true, true},
+      {1024 * 1024, std::align_val_t{128}, std::nullopt, true, true},
+      {32, std::nullopt, tcmalloc::hot_cold_t{0}, false, true},
+      {64, std::nullopt, tcmalloc::hot_cold_t{255}, true, true},
+      {8192, std::nullopt, tcmalloc::hot_cold_t{0}, false, true},
   };
   absl::btree_set<size_t> sizes_expected;
   for (auto s : sizes) {
@@ -196,17 +196,17 @@ TEST(AllocationSampleTest, SampleAccuracy) {
   for (auto& s : sizes) {
     for (size_t bytes = 0; bytes < kTotalPerSize; bytes += s.size) {
       void* obj;
-      if (s.alignment > 0) {
-        obj = operator new(s.size, static_cast<std::align_val_t>(s.alignment));
+      if (s.alignment.has_value()) {
+        obj = operator new(s.size, *s.alignment);
       } else if (s.hot_cold.has_value()) {
         obj = operator new(s.size, *s.hot_cold);
       } else {
         obj = operator new(s.size);
       }
       if (s.keep) {
         tcmalloc_internal::SLL_Push(&s.list, obj);
-      } else if (s.alignment > 0) {
-        operator delete(obj, static_cast<std::align_val_t>(s.alignment));
+      } else if (s.alignment.has_value()) {
+        operator delete(obj, *s.alignment);
       } else {
         sized_delete(obj, s.size);
       }
@@ -218,7 +218,7 @@ TEST(AllocationSampleTest, SampleAccuracy) {
   absl::flat_hash_map<size_t, size_t> m;
 
   // size -> alignment request
-  absl::flat_hash_map<size_t, size_t> alignment;
+  absl::flat_hash_map<size_t, std::optional<std::align_val_t>> alignment;
 
   // size -> access_hint
   absl::flat_hash_map<size_t, hot_cold_t> access_hint;
@@ -267,8 +267,8 @@ TEST(AllocationSampleTest, SampleAccuracy) {
   for (auto& s : sizes) {
     while (s.list != nullptr) {
       void* obj = tcmalloc_internal::SLL_Pop(&s.list);
-      if (s.alignment > 0) {
-        operator delete(obj, static_cast<std::align_val_t>(s.alignment));
+      if (s.alignment.has_value()) {
+        operator delete(obj, *s.alignment);
       } else {
         operator delete(obj);
       }

tcmalloc/stack_trace_table.cc

@@ -18,6 +18,8 @@
 #include <string.h>
 
 #include <cstdint>
+#include <new>
+#include <optional>
 
 #include "absl/functional/function_ref.h"
 #include "tcmalloc/common.h"
@@ -78,7 +80,13 @@ void StackTraceTable::AddTrace(double sample_weight, const StackTrace& t) {
   }
   s->sample.sum = s->sample.count * allocated_size;
   s->sample.requested_size = requested_size;
-  s->sample.requested_alignment = t.requested_alignment;
+  // TODO(b/404341539): Propagate type to StackTrace.
+  if (t.requested_alignment > 0) {
+    s->sample.requested_alignment =
+        static_cast<std::align_val_t>(t.requested_alignment);
+  } else {
+    s->sample.requested_alignment = std::nullopt;
+  }
   s->sample.requested_size_returning = t.requested_size_returning;
   s->sample.allocated_size = allocated_size;
   s->sample.alloc_handle = t.sampled_alloc_handle;

tcmalloc/stack_trace_table_test.cc

@@ -19,6 +19,8 @@
 
 #include <algorithm>
 #include <initializer_list>
+#include <new>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -42,7 +44,7 @@ struct AllocationEntry {
   int64_t sum;
   int count;
   size_t requested_size;
-  size_t requested_alignment;
+  std::optional<std::align_val_t> requested_alignment;
   size_t allocated_size;
   MallocHook::AllocHandle alloc_handle;
   uint8_t access_hint;
@@ -160,7 +162,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = 1024,
       .count = 1,
       .requested_size = 512,
-      .requested_alignment = 16,
+      .requested_alignment = std::align_val_t{16},
       .allocated_size = 1024,
       .alloc_handle = AllocHandle{1},
       .access_hint = 3,
@@ -185,7 +187,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = 512,
       .count = 1,
       .requested_size = 375,
-      .requested_alignment = 0,
+      .requested_alignment = std::nullopt,
       .allocated_size = 512,
       .alloc_handle = AllocHandle{2},
       .access_hint = 254,
@@ -221,7 +223,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = t1_sampled_weight * 1024,
       .count = t1_sampled_weight,
       .requested_size = 512,
-      .requested_alignment = 16,
+      .requested_alignment = std::align_val_t{16},
       .allocated_size = 1024,
       .alloc_handle = AllocHandle{1},
       .access_hint = 3,
@@ -294,7 +296,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = 17,
       .count = 1,
       .requested_size = 13,
-      .requested_alignment = 0,
+      .requested_alignment = std::nullopt,
       .allocated_size = 17,
       .alloc_handle = AllocHandle{3},
       .access_hint = 3,
@@ -332,7 +334,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = 1024,
       .count = 1,
       .requested_size = 512,
-      .requested_alignment = 32,
+      .requested_alignment = std::align_val_t{32},
       .allocated_size = 1024,
       .alloc_handle = AllocHandle{4},
       .access_hint = 3,
@@ -370,7 +372,7 @@ TEST(StackTraceTableTest, StackTraceTable) {
       .sum = 1024,
       .count = 1,
       .requested_size = 512,
-      .requested_alignment = 32,
+      .requested_alignment = std::align_val_t{32},
       .allocated_size = 1024,
       .alloc_handle = AllocHandle{5},
       .access_hint = 4,

tcmalloc/testing/aligned_new_test.cc

@@ -16,6 +16,7 @@
 #include <stdint.h>
 
 #include <memory>
+#include <new>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -91,18 +92,20 @@ TYPED_TEST_P(AlignedNew, AlignedTest) {
   // __STDCPP_DEFAULT_NEW_ALIGNMENT__.
   //
   // (size, alignment) -> count
-  using CountMap = absl::flat_hash_map<std::pair<size_t, size_t>, size_t>;
+  using CountMap =
+      absl::flat_hash_map<std::pair<size_t, std::align_val_t>, size_t>;
   CountMap counts;
 
   profile.Iterate([&](const Profile::Sample& e) {
-    counts[{e.requested_size, e.requested_alignment}] += e.count;
+    counts[{e.requested_size,
+            e.requested_alignment.value_or(std::align_val_t{0})}] += e.count;
   });
 
   if (!tcmalloc_internal::kSanitizerPresent) {
-    size_t expected_alignment = 0;
+    std::align_val_t expected_alignment{0};
 #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
     if (alignof(TypeParam) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
-      expected_alignment = alignof(TypeParam);
+      expected_alignment = static_cast<std::align_val_t>(alignof(TypeParam));
     }
 #endif
     EXPECT_GT((counts[{sizeof(TypeParam), expected_alignment}]), 0);