[iomgr] Restrict TCP read allocations to 8kb or 64kb (#30626)

* [stats] Cleanup stats system * clear out optionality * fix * might as well... * Automated change: Fix sanity tests * only allocate 8k or 64k blocks for tcp reads * Automated change: Fix sanity tests * fix * Update tcp_posix.cc * Automated change: Fix sanity tests * respect target, min progress sizes * cleaner loops * clean out more unused stuff * clean out more unused stuff * Automated change: Fix sanity tests * update * tsan race * Automated change: Fix sanity tests * Introduce flag * protect with flag * [experiments] Make output more diffable/readable * Automated change: Fix sanity tests * buildifier sized indentations Co-authored-by: ctiller <ctiller@users.noreply.github.com>
2 years ago · 903e0490ea
parent bf9304ef17
commit 903e0490ea
11 changed files with 146 additions and 147 deletions
--- a/bazel/experiments.bzl
+++ b/bazel/experiments.bzl
@ -19,8 +19,10 @@
 EXPERIMENTS = {
    "core_end2end_test": [
        "tcp_frame_size_tuning",
+        "tcp_read_chunks",
    ],
    "endpoint_test": [
        "tcp_frame_size_tuning",
+        "tcp_read_chunks",
    ],
 }
--- a/src/core/lib/debug/stats_data.cc
+++ b/src/core/lib/debug/stats_data.cc
@ -32,6 +32,7 @@ const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
    "client_channels_created", "client_subchannels_created",
    "server_channels_created", "histogram_slow_lookups",
    "syscall_write",           "syscall_read",
+    "tcp_read_alloc_8k",       "tcp_read_alloc_64k",
    "http2_settings_writes",   "http2_pings_sent",
    "http2_writes_begun",      "http2_transport_stalls",
    "http2_stream_stalls",
@ -47,6 +48,8 @@ const char* grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
    "Number of write syscalls (or equivalent - eg sendmsg) made by this "
    "process",
    "Number of read syscalls (or equivalent - eg recvmsg) made by this process",
+    "Number of 8k allocations by the TCP subsystem for reading",
+    "Number of 64k allocations by the TCP subsystem for reading",
    "Number of settings frames sent",
    "Number of HTTP2 pings sent by process",
    "Number of HTTP2 writes initiated",
@ -56,15 +59,14 @@ const char* grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
    "window",
 };
 const char* grpc_stats_histogram_name[GRPC_STATS_HISTOGRAM_COUNT] = {
-    "call_initial_size",       "tcp_write_size",          "tcp_write_iov_size",
-    "tcp_read_allocation",     "tcp_read_size",           "tcp_read_offer",
-    "tcp_read_offer_iov_size", "http2_send_message_size",
+    "call_initial_size",       "tcp_write_size", "tcp_write_iov_size",
+    "tcp_read_size",           "tcp_read_offer", "tcp_read_offer_iov_size",
+    "http2_send_message_size",
 };
 const char* grpc_stats_histogram_doc[GRPC_STATS_HISTOGRAM_COUNT] = {
    "Initial size of the grpc_call arena created at call start",
    "Number of bytes offered to each syscall_write",
    "Number of byte segments offered to each syscall_write",
-    "Number of bytes allocated in each slice by tcp reads",
    "Number of bytes received by each syscall_read",
    "Number of bytes offered to each syscall_read",
    "Number of byte segments offered to each syscall_read",
@ -184,29 +186,6 @@ void grpc_stats_inc_tcp_write_iov_size(int value) {
      GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,
      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
-void grpc_stats_inc_tcp_read_allocation(int value) {
-  value = grpc_core::Clamp(value, 0, 16777216);
-  if (value < 5) {
-    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION, value);
-    return;
-  }
-  union {
-    double dbl;
-    uint64_t uint;
-  } _val, _bkt;
-  _val.dbl = value;
-  if (_val.uint < 4683743612465315840ull) {
-    int bucket =
-        grpc_stats_table_3[((_val.uint - 4617315517961601024ull) >> 50)] + 5;
-    _bkt.dbl = grpc_stats_table_2[bucket];
-    bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION, bucket);
-    return;
-  }
-  GRPC_STATS_INC_HISTOGRAM(
-      GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION,
-      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_2, 64));
-}
 void grpc_stats_inc_tcp_read_size(int value) {
  value = grpc_core::Clamp(value, 0, 16777216);
  if (value < 5) {
@ -303,17 +282,16 @@ void grpc_stats_inc_http2_send_message_size(int value) {
      GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_2, 64));
 }
-const int grpc_stats_histo_buckets[8] = {64, 64, 64, 64, 64, 64, 64, 64};
-const int grpc_stats_histo_start[8] = {0, 64, 128, 192, 256, 320, 384, 448};
-const int* const grpc_stats_histo_bucket_boundaries[8] = {
+const int grpc_stats_histo_buckets[7] = {64, 64, 64, 64, 64, 64, 64};
+const int grpc_stats_histo_start[7] = {0, 64, 128, 192, 256, 320, 384};
+const int* const grpc_stats_histo_bucket_boundaries[7] = {
    grpc_stats_table_0, grpc_stats_table_2, grpc_stats_table_4,
-    grpc_stats_table_2, grpc_stats_table_2, grpc_stats_table_2,
-    grpc_stats_table_4, grpc_stats_table_2};
-void (*const grpc_stats_inc_histogram[8])(int x) = {
+    grpc_stats_table_2, grpc_stats_table_2, grpc_stats_table_4,
+    grpc_stats_table_2};
+void (*const grpc_stats_inc_histogram[7])(int x) = {
    grpc_stats_inc_call_initial_size,
    grpc_stats_inc_tcp_write_size,
    grpc_stats_inc_tcp_write_iov_size,
-    grpc_stats_inc_tcp_read_allocation,
    grpc_stats_inc_tcp_read_size,
    grpc_stats_inc_tcp_read_offer,
    grpc_stats_inc_tcp_read_offer_iov_size,
--- a/src/core/lib/debug/stats_data.h
+++ b/src/core/lib/debug/stats_data.h
@ -32,6 +32,8 @@ typedef enum {
  GRPC_STATS_COUNTER_HISTOGRAM_SLOW_LOOKUPS,
  GRPC_STATS_COUNTER_SYSCALL_WRITE,
  GRPC_STATS_COUNTER_SYSCALL_READ,
+  GRPC_STATS_COUNTER_TCP_READ_ALLOC_8K,
+  GRPC_STATS_COUNTER_TCP_READ_ALLOC_64K,
  GRPC_STATS_COUNTER_HTTP2_SETTINGS_WRITES,
  GRPC_STATS_COUNTER_HTTP2_PINGS_SENT,
  GRPC_STATS_COUNTER_HTTP2_WRITES_BEGUN,
@ -45,7 +47,6 @@ typedef enum {
  GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
  GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,
-  GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION,
  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
@ -61,17 +62,15 @@ typedef enum {
  GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE_BUCKETS = 64,
  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE_FIRST_SLOT = 128,
  GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION_FIRST_SLOT = 192,
-  GRPC_STATS_HISTOGRAM_TCP_READ_ALLOCATION_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE_FIRST_SLOT = 256,
+  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE_FIRST_SLOT = 192,
  GRPC_STATS_HISTOGRAM_TCP_READ_SIZE_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_FIRST_SLOT = 320,
+  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_FIRST_SLOT = 256,
  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE_FIRST_SLOT = 384,
+  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE_FIRST_SLOT = 320,
  GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE_FIRST_SLOT = 448,
+  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE_FIRST_SLOT = 384,
  GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_BUCKETS = 512
+  GRPC_STATS_HISTOGRAM_BUCKETS = 448
 } grpc_stats_histogram_constants;
 #define GRPC_STATS_INC_CLIENT_CALLS_CREATED() \
  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED)
@ -89,6 +88,10 @@ typedef enum {
  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_WRITE)
 #define GRPC_STATS_INC_SYSCALL_READ() \
  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_SYSCALL_READ)
+#define GRPC_STATS_INC_TCP_READ_ALLOC_8K() \
+  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_TCP_READ_ALLOC_8K)
+#define GRPC_STATS_INC_TCP_READ_ALLOC_64K() \
+  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_TCP_READ_ALLOC_64K)
 #define GRPC_STATS_INC_HTTP2_SETTINGS_WRITES() \
  GRPC_STATS_INC_COUNTER(GRPC_STATS_COUNTER_HTTP2_SETTINGS_WRITES)
 #define GRPC_STATS_INC_HTTP2_PINGS_SENT() \
@ -108,9 +111,6 @@ void grpc_stats_inc_tcp_write_size(int x);
 #define GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(value) \
  grpc_stats_inc_tcp_write_iov_size((int)(value))
 void grpc_stats_inc_tcp_write_iov_size(int x);
-#define GRPC_STATS_INC_TCP_READ_ALLOCATION(value) \
-  grpc_stats_inc_tcp_read_allocation((int)(value))
-void grpc_stats_inc_tcp_read_allocation(int x);
 #define GRPC_STATS_INC_TCP_READ_SIZE(value) \
  grpc_stats_inc_tcp_read_size((int)(value))
 void grpc_stats_inc_tcp_read_size(int x);
@ -123,9 +123,9 @@ void grpc_stats_inc_tcp_read_offer_iov_size(int x);
 #define GRPC_STATS_INC_HTTP2_SEND_MESSAGE_SIZE(value) \
  grpc_stats_inc_http2_send_message_size((int)(value))
 void grpc_stats_inc_http2_send_message_size(int x);
-extern const int grpc_stats_histo_buckets[8];
-extern const int grpc_stats_histo_start[8];
-extern const int* const grpc_stats_histo_bucket_boundaries[8];
-extern void (*const grpc_stats_inc_histogram[8])(int x);
+extern const int grpc_stats_histo_buckets[7];
+extern const int grpc_stats_histo_start[7];
+extern const int* const grpc_stats_histo_bucket_boundaries[7];
+extern void (*const grpc_stats_inc_histogram[7])(int x);

 #endif /* GRPC_CORE_LIB_DEBUG_STATS_DATA_H */
--- a/src/core/lib/debug/stats_data.yaml
+++ b/src/core/lib/debug/stats_data.yaml
@ -47,10 +47,10 @@
  max: 1024
  buckets: 64
  doc: Number of byte segments offered to each syscall_write
- histogram: tcp_read_allocation
-  max: 16777216
-  buckets: 64
-  doc: Number of bytes allocated in each slice by tcp reads
+- counter: tcp_read_alloc_8k
+  doc: Number of 8k allocations by the TCP subsystem for reading
+- counter: tcp_read_alloc_64k
+  doc: Number of 64k allocations by the TCP subsystem for reading
 - histogram: tcp_read_size
  max: 16777216
  buckets: 64
--- a/src/core/lib/debug/stats_data_bq_schema.sql
+++ b/src/core/lib/debug/stats_data_bq_schema.sql
@ -6,6 +6,8 @@ server_channels_created_per_iteration:FLOAT,
 histogram_slow_lookups_per_iteration:FLOAT,
 syscall_write_per_iteration:FLOAT,
 syscall_read_per_iteration:FLOAT,
+tcp_read_alloc_8k_per_iteration:FLOAT,
+tcp_read_alloc_64k_per_iteration:FLOAT,
 http2_settings_writes_per_iteration:FLOAT,
 http2_pings_sent_per_iteration:FLOAT,
 http2_writes_begun_per_iteration:FLOAT,
--- a/src/core/lib/experiments/experiments.cc
+++ b/src/core/lib/experiments/experiments.cc
@ -26,10 +26,15 @@ const char* const description_tcp_frame_size_tuning =
    "would not indicate completion of a read operation until a specified "
    "number of bytes have been read over the socket. Buffers are also "
    "allocated according to estimated RPC sizes.";
-}
+const char* const description_tcp_read_chunks =
+    "Allocate only 8kb or 64kb chunks for TCP reads to reduce pressure on "
+    "malloc to recycle arbitrary large blocks.";
+}  // namespace

 GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_experimental_enable_tcp_frame_size_tuning,
                              false, description_tcp_frame_size_tuning);
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_experimental_enable_tcp_read_chunks, false,
+                              description_tcp_read_chunks);

 namespace grpc_core {

@ -38,10 +43,17 @@ bool IsTcpFrameSizeTuningEnabled() {
      GPR_GLOBAL_CONFIG_GET(grpc_experimental_enable_tcp_frame_size_tuning);
  return enabled;
 }
+bool IsTcpReadChunksEnabled() {
+  static const bool enabled =
+      GPR_GLOBAL_CONFIG_GET(grpc_experimental_enable_tcp_read_chunks);
+  return enabled;
+}

 const ExperimentMetadata g_experiment_metadata[] = {
    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false,
     IsTcpFrameSizeTuningEnabled},
+    {"tcp_read_chunks", description_tcp_read_chunks, false,
+     IsTcpReadChunksEnabled},
 };

 }  // namespace grpc_core
--- a/src/core/lib/experiments/experiments.h
+++ b/src/core/lib/experiments/experiments.h
@ -24,6 +24,7 @@
 namespace grpc_core {

 bool IsTcpFrameSizeTuningEnabled();
+bool IsTcpReadChunksEnabled();

 struct ExperimentMetadata {
  const char* name;
@ -32,7 +33,7 @@ struct ExperimentMetadata {
  bool (*is_enabled)();
 };

-constexpr const size_t kNumExperiments = 1;
+constexpr const size_t kNumExperiments = 2;
 extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];

 }  // namespace grpc_core
--- a/src/core/lib/experiments/experiments.yaml
+++ b/src/core/lib/experiments/experiments.yaml
@ -35,3 +35,11 @@
  expiry: 2022/09/01
  owner: ctiller@google.com
  test_tags: ["endpoint_test", "core_end2end_test"]
+- name: tcp_read_chunks
+  description:
+    Allocate only 8kb or 64kb chunks for TCP reads to reduce pressure on
+    malloc to recycle arbitrary large blocks.
+  default: false
+  expiry: 2022/09/01
+  owner: ctiller@google.com
+  test_tags: ["endpoint_test", "core_end2end_test"]
--- a/src/core/lib/iomgr/tcp_posix.cc
+++ b/src/core/lib/iomgr/tcp_posix.cc
@ -20,6 +20,7 @@

 #include <grpc/impl/codegen/grpc_types.h>

+#include "src/core/lib/gprpp/global_config_generic.h"
 #include "src/core/lib/iomgr/port.h"

 #ifdef GRPC_POSIX_SOCKET_TCP
@ -473,7 +474,7 @@ struct grpc_tcp {
  /* Used by the endpoint read function to distinguish the very first read call
   * from the rest */
  bool is_first_read;
-  bool has_posted_reclaimer;
+  bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
  double target_length;
  double bytes_read_this_round;
  grpc_core::RefCount refcount;
@ -783,8 +784,8 @@ static void perform_reclamation(grpc_tcp* tcp)
  if (tcp->incoming_buffer != nullptr) {
    grpc_slice_buffer_reset_and_unref_internal(tcp->incoming_buffer);
  }
-  tcp->read_mu.Unlock();
  tcp->has_posted_reclaimer = false;
+  tcp->read_mu.Unlock();
 }

 static void maybe_post_reclaimer(grpc_tcp* tcp)
@ -820,7 +821,7 @@ static void tcp_trace_read(grpc_tcp* tcp, grpc_error_handle error)
 }

 /* Returns true if data available to read or error other than EAGAIN. */
-#define MAX_READ_IOVEC 4
+#define MAX_READ_IOVEC 64
 static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
    ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
@ -998,30 +999,66 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)

 static void maybe_make_read_slices(grpc_tcp* tcp)
    ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
-  if (tcp->incoming_buffer->length <
-          static_cast<size_t>(tcp->min_progress_size) &&
-      tcp->incoming_buffer->count < MAX_READ_IOVEC) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO,
-              "TCP:%p alloc_slices; min_chunk=%d max_chunk=%d target=%lf "
-              "buf_len=%" PRIdPTR,
-              tcp, tcp->min_read_chunk_size, tcp->max_read_chunk_size,
-              tcp->target_length, tcp->incoming_buffer->length);
+  if (grpc_core::IsTcpReadChunksEnabled()) {
+    static const int kBigAlloc = 64 * 1024;
+    static const int kSmallAlloc = 8 * 1024;
+    if (tcp->incoming_buffer->length <
+        static_cast<size_t>(tcp->min_progress_size)) {
+      size_t allocate_length = tcp->min_progress_size;
+      const size_t target_length = static_cast<size_t>(tcp->target_length);
+      // If memory pressure is low and we think there will be more than
+      // min_progress_size bytes to read, allocate a bit more.
+      const bool low_memory_pressure =
+          tcp->memory_owner.GetPressureInfo().pressure_control_value < 0.8;
+      if (low_memory_pressure && target_length > allocate_length) {
+        allocate_length = target_length;
+      }
+      int extra_wanted =
+          allocate_length - static_cast<int>(tcp->incoming_buffer->length);
+      if (extra_wanted >=
+          (low_memory_pressure ? kSmallAlloc * 3 / 2 : kBigAlloc)) {
+        while (extra_wanted > 0) {
+          extra_wanted -= kBigAlloc;
+          grpc_slice_buffer_add_indexed(tcp->incoming_buffer,
+                                        tcp->memory_owner.MakeSlice(kBigAlloc));
+          GRPC_STATS_INC_TCP_READ_ALLOC_64K();
+        }
+      } else {
+        while (extra_wanted > 0) {
+          extra_wanted -= kSmallAlloc;
+          grpc_slice_buffer_add_indexed(
+              tcp->incoming_buffer, tcp->memory_owner.MakeSlice(kSmallAlloc));
+          GRPC_STATS_INC_TCP_READ_ALLOC_8K();
+        }
+      }
+      maybe_post_reclaimer(tcp);
+    }
+  } else {
+    if (tcp->incoming_buffer->length <
+            static_cast<size_t>(tcp->min_progress_size) &&
+        tcp->incoming_buffer->count < MAX_READ_IOVEC) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+        gpr_log(GPR_INFO,
+                "TCP:%p alloc_slices; min_chunk=%d max_chunk=%d target=%lf "
+                "buf_len=%" PRIdPTR,
+                tcp, tcp->min_read_chunk_size, tcp->max_read_chunk_size,
+                tcp->target_length, tcp->incoming_buffer->length);
+      }
+      int target_length = std::max(static_cast<int>(tcp->target_length),
+                                   tcp->min_progress_size);
+      int extra_wanted =
+          target_length - static_cast<int>(tcp->incoming_buffer->length);
+      int min_read_chunk_size =
+          std::max(tcp->min_read_chunk_size, tcp->min_progress_size);
+      int max_read_chunk_size =
+          std::max(tcp->max_read_chunk_size, tcp->min_progress_size);
+      grpc_slice slice = tcp->memory_owner.MakeSlice(grpc_core::MemoryRequest(
+          min_read_chunk_size,
+          grpc_core::Clamp(extra_wanted, min_read_chunk_size,
+                           max_read_chunk_size)));
+      grpc_slice_buffer_add_indexed(tcp->incoming_buffer, slice);
+      maybe_post_reclaimer(tcp);
    }
-    int target_length =
-        std::max(static_cast<int>(tcp->target_length), tcp->min_progress_size);
-    int extra_wanted =
-        target_length - static_cast<int>(tcp->incoming_buffer->length);
-    int min_read_chunk_size =
-        std::max(tcp->min_read_chunk_size, tcp->min_progress_size);
-    int max_read_chunk_size =
-        std::max(tcp->max_read_chunk_size, tcp->min_progress_size);
-    grpc_slice slice = tcp->memory_owner.MakeSlice(grpc_core::MemoryRequest(
-        min_read_chunk_size, grpc_core::Clamp(extra_wanted, min_read_chunk_size,
-                                              max_read_chunk_size)));
-    GRPC_STATS_INC_TCP_READ_ALLOCATION(GRPC_SLICE_LENGTH(slice));
-    grpc_slice_buffer_add_indexed(tcp->incoming_buffer, slice);
-    maybe_post_reclaimer(tcp);
  }
 }

@ -1944,7 +1981,6 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
  tcp->bytes_read_this_round = 0;
  /* Will be set to false by the very first endpoint read function */
  tcp->is_first_read = true;
-  tcp->has_posted_reclaimer = false;
  tcp->bytes_counter = -1;
  tcp->socket_ts_enabled = false;
  tcp->ts_capable = true;
--- a/tools/run_tests/performance/massage_qps_stats.py
+++ b/tools/run_tests/performance/massage_qps_stats.py
@ -46,6 +46,11 @@ def massage_qps_stats(scenario_result):
                core_stats, "syscall_write")
            stats["core_syscall_read"] = massage_qps_stats_helpers.counter(
                core_stats, "syscall_read")
+            stats["core_tcp_read_alloc_8k"] = massage_qps_stats_helpers.counter(
+                core_stats, "tcp_read_alloc_8k")
+            stats[
+                "core_tcp_read_alloc_64k"] = massage_qps_stats_helpers.counter(
+                    core_stats, "tcp_read_alloc_64k")
            stats[
                "core_http2_settings_writes"] = massage_qps_stats_helpers.counter(
                    core_stats, "http2_settings_writes")
@ -104,21 +109,6 @@ def massage_qps_stats(scenario_result):
            stats[
                "core_tcp_write_iov_size_99p"] = massage_qps_stats_helpers.percentile(
                    h.buckets, 99, h.boundaries)
-            h = massage_qps_stats_helpers.histogram(core_stats,
-                                                    "tcp_read_allocation")
-            stats["core_tcp_read_allocation"] = ",".join(
-                "%f" % x for x in h.buckets)
-            stats["core_tcp_read_allocation_bkts"] = ",".join(
-                "%f" % x for x in h.boundaries)
-            stats[
-                "core_tcp_read_allocation_50p"] = massage_qps_stats_helpers.percentile(
-                    h.buckets, 50, h.boundaries)
-            stats[
-                "core_tcp_read_allocation_95p"] = massage_qps_stats_helpers.percentile(
-                    h.buckets, 95, h.boundaries)
-            stats[
-                "core_tcp_read_allocation_99p"] = massage_qps_stats_helpers.percentile(
-                    h.buckets, 99, h.boundaries)
            h = massage_qps_stats_helpers.histogram(core_stats, "tcp_read_size")
            stats["core_tcp_read_size"] = ",".join("%f" % x for x in h.buckets)
            stats["core_tcp_read_size_bkts"] = ",".join(
--- a/tools/run_tests/performance/scenario_result_schema.json
+++ b/tools/run_tests/performance/scenario_result_schema.json
@ -150,6 +150,16 @@
        "name": "core_syscall_read",
        "type": "INTEGER"
      },
+      {
+        "mode": "NULLABLE",
+        "name": "core_tcp_read_alloc_8k",
+        "type": "INTEGER"
+      },
+      {
+        "mode": "NULLABLE",
+        "name": "core_tcp_read_alloc_64k",
+        "type": "INTEGER"
+      },
      {
        "mode": "NULLABLE",
        "name": "core_http2_settings_writes",
@ -250,31 +260,6 @@
        "name": "core_tcp_write_iov_size_99p",
        "type": "FLOAT"
      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation",
-        "type": "STRING"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_bkts",
-        "type": "STRING"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_50p",
-        "type": "FLOAT"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_95p",
-        "type": "FLOAT"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_99p",
-        "type": "FLOAT"
-      },
      {
        "mode": "NULLABLE",
        "name": "core_tcp_read_size",
@ -442,6 +427,16 @@
        "name": "core_syscall_read",
        "type": "INTEGER"
      },
+      {
+        "mode": "NULLABLE",
+        "name": "core_tcp_read_alloc_8k",
+        "type": "INTEGER"
+      },
+      {
+        "mode": "NULLABLE",
+        "name": "core_tcp_read_alloc_64k",
+        "type": "INTEGER"
+      },
      {
        "mode": "NULLABLE",
        "name": "core_http2_settings_writes",
@ -542,31 +537,6 @@
        "name": "core_tcp_write_iov_size_99p",
        "type": "FLOAT"
      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation",
-        "type": "STRING"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_bkts",
-        "type": "STRING"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_50p",
-        "type": "FLOAT"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_95p",
-        "type": "FLOAT"
-      },
-      {
-        "mode": "NULLABLE",
-        "name": "core_tcp_read_allocation_99p",
-        "type": "FLOAT"
-      },
      {
        "mode": "NULLABLE",
        "name": "core_tcp_read_size",