Revert "Renamed macros for memory alignment"

This reverts commit a3fe7c0.
tmatsuo · May 6, 2019 · cb966a4 · cb966a4
1 parent 0562b51
commit cb966a4
Show file tree

Hide file tree

Showing 9 changed files with 56 additions and 61 deletions.
diff --git a/src/core/ext/filters/client_channel/subchannel.cc b/src/core/ext/filters/client_channel/subchannel.cc
@@ -66,13 +66,12 @@
 #define GRPC_SUBCHANNEL_RECONNECT_JITTER 0.2
 
 // Conversion between subchannel call and call stack.
-#define SUBCHANNEL_CALL_TO_CALL_STACK(call)                              \
-  (grpc_call_stack*)((char*)(call) + GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE( \
-                                         sizeof(SubchannelCall)))
-#define CALL_STACK_TO_SUBCHANNEL_CALL(callstack)        \
-  (SubchannelCall*)(((char*)(call_stack)) -             \
-                    GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE( \
-                        sizeof(SubchannelCall)))
+#define SUBCHANNEL_CALL_TO_CALL_STACK(call) \
+  (grpc_call_stack*)((char*)(call) +        \
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)))
+#define CALL_STACK_TO_SUBCHANNEL_CALL(callstack) \
+  (SubchannelCall*)(((char*)(call_stack)) -      \
+                    GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)))
 
 namespace grpc_core {
 
@@ -152,10 +151,10 @@ RefCountedPtr<SubchannelCall> ConnectedSubchannel::CreateCall(
 size_t ConnectedSubchannel::GetInitialCallSizeEstimate(
     size_t parent_data_size) const {
   size_t allocation_size =
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(SubchannelCall));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall));
   if (parent_data_size > 0) {
     allocation_size +=
-        GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(channel_stack_->call_stack_size) +
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(channel_stack_->call_stack_size) +
         parent_data_size;
   } else {
     allocation_size += channel_stack_->call_stack_size;
@@ -179,9 +178,8 @@ void SubchannelCall::StartTransportStreamOpBatch(
 
 void* SubchannelCall::GetParentData() {
   grpc_channel_stack* chanstk = connected_subchannel_->channel_stack();
-  return (char*)this +
-         GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(SubchannelCall)) +
-         GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(chanstk->call_stack_size);
+  return (char*)this + GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)) +
+         GPR_ROUND_UP_TO_ALIGNMENT_SIZE(chanstk->call_stack_size);
 }
 
 grpc_call_stack* SubchannelCall::GetCallStack() {

diff --git a/src/core/lib/channel/channel_stack.cc b/src/core/lib/channel/channel_stack.cc
@@ -47,28 +47,28 @@ grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count) {
   /* always need the header, and size for the channel elements */
-  size_t size = GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
-                GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(
-                    filter_count * sizeof(grpc_channel_element));
+  size_t size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+                                               sizeof(grpc_channel_element));
   size_t i;
 
   GPR_ASSERT((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 &&
              "GPR_MAX_ALIGNMENT must be a power of two");
 
   /* add the size for each filter */
   for (i = 0; i < filter_count; i++) {
-    size += GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+    size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
   }
 
   return size;
 }
 
-#define CHANNEL_ELEMS_FROM_STACK(stk)                                         \
-  ((grpc_channel_element*)((char*)(stk) + GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE( \
+#define CHANNEL_ELEMS_FROM_STACK(stk)                                     \
+  ((grpc_channel_element*)((char*)(stk) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
                                               sizeof(grpc_channel_stack))))
 
-#define CALL_ELEMS_FROM_STACK(stk)                                         \
-  ((grpc_call_element*)((char*)(stk) + GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE( \
+#define CALL_ELEMS_FROM_STACK(stk)                                     \
+  ((grpc_call_element*)((char*)(stk) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
                                            sizeof(grpc_call_stack))))
 
 grpc_channel_element* grpc_channel_stack_element(
@@ -92,9 +92,8 @@ grpc_error* grpc_channel_stack_init(
     const grpc_channel_args* channel_args, grpc_transport* optional_transport,
     const char* name, grpc_channel_stack* stack) {
   size_t call_size =
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(filter_count *
-                                         sizeof(grpc_call_element));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
   grpc_channel_element* elems;
   grpc_channel_element_args args;
   char* user_data;
@@ -105,8 +104,8 @@ grpc_error* grpc_channel_stack_init(
                        name);
   elems = CHANNEL_ELEMS_FROM_STACK(stack);
   user_data = (reinterpret_cast<char*>(elems)) +
-              GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(filter_count *
-                                                 sizeof(grpc_channel_element));
+              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count *
+                                             sizeof(grpc_channel_element));
 
   /* init per-filter data */
   grpc_error* first_error = GRPC_ERROR_NONE;
@@ -127,9 +126,8 @@ grpc_error* grpc_channel_stack_init(
       }
     }
     user_data +=
-        GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
-    call_size +=
-        GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+    call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
   }
 
   GPR_ASSERT(user_data > (char*)stack);
@@ -164,18 +162,17 @@ grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
   GRPC_STREAM_REF_INIT(&elem_args->call_stack->refcount, initial_refs, destroy,
                        destroy_arg, "CALL_STACK");
   call_elems = CALL_ELEMS_FROM_STACK(elem_args->call_stack);
-  user_data =
-      (reinterpret_cast<char*>(call_elems)) +
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
+  user_data = (reinterpret_cast<char*>(call_elems)) +
+              GPR_ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
   grpc_error* first_error = GRPC_ERROR_NONE;
   for (size_t i = 0; i < count; i++) {
     call_elems[i].filter = channel_elems[i].filter;
     call_elems[i].channel_data = channel_elems[i].channel_data;
     call_elems[i].call_data = user_data;
-    user_data += GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(
-        call_elems[i].filter->sizeof_call_data);
+    user_data +=
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data);
   }
   for (size_t i = 0; i < count; i++) {
     grpc_error* error =
@@ -245,11 +242,11 @@ grpc_channel_stack* grpc_channel_stack_from_top_element(
     grpc_channel_element* elem) {
   return reinterpret_cast<grpc_channel_stack*>(
       reinterpret_cast<char*>(elem) -
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)));
 }
 
 grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
   return reinterpret_cast<grpc_call_stack*>(
       reinterpret_cast<char*>(elem) -
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_call_stack)));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)));
 }
diff --git a/src/core/lib/gpr/alloc.cc b/src/core/lib/gpr/alloc.cc
@@ -56,7 +56,7 @@ static void aligned_free_with_gpr_malloc(void* ptr) {
 
 static void* platform_malloc_aligned(size_t size, size_t alignment) {
 #if defined(GPR_HAS_ALIGNED_ALLOC)
-  size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size, alignment);
+  size = GPR_ROUND_UP_TO_SPECIFIED_SIZE(size, alignment);
   void* ret = aligned_alloc(alignment, size);
   GPR_ASSERT(ret != nullptr);
   return ret;

diff --git a/src/core/lib/gpr/alloc.h b/src/core/lib/gpr/alloc.h
@@ -22,13 +22,15 @@
 #include <grpc/support/port_platform.h>
 
 /// Given a size, round up to the next multiple of sizeof(void*).
-#define GPR_ROUND_UP_TO_ALIGNMENT_SIZE(x, align) \
-  (((x) + (align)-1u) & ~((align)-1u))
-
-#define GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(x) \
-  GPR_ROUND_UP_TO_ALIGNMENT_SIZE((x), GPR_MAX_ALIGNMENT)
+#define GPR_ROUND_UP_TO_ALIGNMENT_SIZE(x) \
+  (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
 
 #define GPR_ROUND_UP_TO_CACHELINE_SIZE(x) \
-  GPR_ROUND_UP_TO_ALIGNMENT_SIZE((x), GPR_CACHELINE_SIZE)
+  (((x) + GPR_CACHELINE_SIZE - 1u) & ~(GPR_CACHELINE_SIZE - 1u))
+
+#define GPR_ROUND_UP_TO_SPECIFIED_SIZE(x, align) \
+  (((x) + align - 1u) & ~(align - 1u))
+
+void* gpr_malloc_cacheline(size_t size);
 
 #endif /* GRPC_CORE_LIB_GPR_ALLOC_H */
diff --git a/src/core/lib/gprpp/arena.cc b/src/core/lib/gprpp/arena.cc
@@ -67,7 +67,7 @@ Arena* Arena::Create(size_t initial_size) {
 Pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size,
                                            size_t alloc_size) {
   static constexpr size_t base_size =
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(Arena));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
   auto* new_arena =
       new (ArenaStorage(initial_size)) Arena(initial_size, alloc_size);
   void* first_alloc = reinterpret_cast<char*>(new_arena) + base_size;
@@ -88,7 +88,7 @@ void* Arena::AllocZone(size_t size) {
   // sizing hysteresis (that is, most calls should have a large enough initial
   // zone and will not need to grow the arena).
   static constexpr size_t zone_base_size =
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(Zone));
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Zone));
   size_t alloc_size = zone_base_size + size;
   Zone* z = new (gpr_malloc_aligned(alloc_size, GPR_MAX_ALIGNMENT)) Zone();
   {

diff --git a/src/core/lib/gprpp/arena.h b/src/core/lib/gprpp/arena.h
@@ -58,8 +58,8 @@ class Arena {
   // Allocate \a size bytes from the arena.
   void* Alloc(size_t size) {
     static constexpr size_t base_size =
-        GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(Arena));
-    size = GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(size);
+        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
+    size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
     size_t begin = total_used_.FetchAdd(size, MemoryOrder::RELAXED);
     if (GPR_LIKELY(begin + size <= initial_zone_size_)) {
       return reinterpret_cast<char*>(this) + base_size + begin;

diff --git a/src/core/lib/surface/call.cc b/src/core/lib/surface/call.cc
@@ -260,10 +260,10 @@ grpc_core::TraceFlag grpc_compression_trace(false, "compression");
 
 #define CALL_STACK_FROM_CALL(call)   \
   (grpc_call_stack*)((char*)(call) + \
-                     GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_call)))
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call)))
 #define CALL_FROM_CALL_STACK(call_stack) \
   (grpc_call*)(((char*)(call_stack)) -   \
-               GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_call)))
+               GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call)))
 
 #define CALL_ELEM_FROM_CALL(call, idx) \
   grpc_call_stack_element(CALL_STACK_FROM_CALL(call), idx)
@@ -329,7 +329,7 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
   size_t initial_size = grpc_channel_get_call_size_estimate(args->channel);
   GRPC_STATS_INC_CALL_INITIAL_SIZE(initial_size);
   size_t call_and_stack_size =
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(grpc_call)) +
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call)) +
       channel_stack->call_stack_size;
   size_t call_alloc_size =
       call_and_stack_size + (args->parent ? sizeof(child_call) : 0);

diff --git a/src/core/lib/transport/transport.cc b/src/core/lib/transport/transport.cc
@@ -115,7 +115,7 @@ void grpc_transport_move_stats(grpc_transport_stream_stats* from,
 }
 
 size_t grpc_transport_stream_size(grpc_transport* transport) {
-  return GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(transport->vtable->sizeof_stream);
+  return GPR_ROUND_UP_TO_ALIGNMENT_SIZE(transport->vtable->sizeof_stream);
 }
 
 void grpc_transport_destroy(grpc_transport* transport) {

diff --git a/test/core/util/memory_counters.cc b/test/core/util/memory_counters.cc
@@ -54,10 +54,9 @@ static void* guard_malloc(size_t size) {
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_absolute, (gpr_atm)1);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_relative, (gpr_atm)1);
   void* ptr = g_old_allocs.malloc_fn(
-      GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size)) + size);
+      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size)) + size);
   *static_cast<size_t*>(ptr) = size;
-  return static_cast<char*>(ptr) +
-         GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size));
+  return static_cast<char*>(ptr) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size));
 }
 
 static void* guard_realloc(void* vptr, size_t size) {
@@ -68,24 +67,23 @@ static void* guard_realloc(void* vptr, size_t size) {
     guard_free(vptr);
     return nullptr;
   }
-  void* ptr = static_cast<char*>(vptr) -
-              GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size));
+  void* ptr =
+      static_cast<char*>(vptr) - GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size));
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_absolute, (gpr_atm)size);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative,
                        -*static_cast<gpr_atm*>(ptr));
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative, (gpr_atm)size);
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_absolute, (gpr_atm)1);
   ptr = g_old_allocs.realloc_fn(
-      ptr, GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size)) + size);
+      ptr, GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size)) + size);
   *static_cast<size_t*>(ptr) = size;
-  return static_cast<char*>(ptr) +
-         GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size));
+  return static_cast<char*>(ptr) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size));
 }
 
 static void guard_free(void* vptr) {
   if (vptr == nullptr) return;
-  void* ptr = static_cast<char*>(vptr) -
-              GPR_ROUND_UP_TO_MAX_ALIGNMENT_SIZE(sizeof(size_t));
+  void* ptr =
+      static_cast<char*>(vptr) - GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(size_t));
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_size_relative,
                        -*static_cast<gpr_atm*>(ptr));
   NO_BARRIER_FETCH_ADD(&g_memory_counters.total_allocs_relative, -(gpr_atm)1);
@@ -95,7 +93,7 @@ static void guard_free(void* vptr) {
 // NB: We do not specify guard_malloc_aligned/guard_free_aligned methods. Since
 // they are null, calls to gpr_malloc_aligned/gpr_free_aligned are executed as a
 // wrapper over gpr_malloc/gpr_free, which do use guard_malloc/guard_free, and
-// thus their allocations are tracked as well.
+// thus there allocations are tracked as well.
 struct gpr_allocation_functions g_guard_allocs = {
     guard_malloc, nullptr, guard_realloc, guard_free, nullptr, nullptr};