grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/compression/stream_compression_gzip.cc

@@ -40,7 +40,7 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
   /* Full flush is not allowed when inflating. */
   GPR_ASSERT(!(ctx->flate == inflate && (flush == Z_FINISH)));
 
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   int r;
   bool eoc = false;
   size_t original_max_output_size = max_output_size;
@@ -57,8 +57,8 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
       r = ctx->flate(&ctx->zs, Z_NO_FLUSH);
       if (r < 0 && r != Z_BUF_ERROR) {
         gpr_log(GPR_ERROR, "zlib error (%d)", r);
-        grpc_slice_unref_internal(&exec_ctx, slice_out);
-        grpc_exec_ctx_finish(&exec_ctx);
+        grpc_slice_unref_internal(slice_out);
+
         return false;
       } else if (r == Z_STREAM_END && ctx->flate == inflate) {
         eoc = true;
@@ -69,7 +69,7 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
             grpc_slice_sub(slice, GRPC_SLICE_LENGTH(slice) - ctx->zs.avail_in,
                            GRPC_SLICE_LENGTH(slice)));
       }
-      grpc_slice_unref_internal(&exec_ctx, slice);
+      grpc_slice_unref_internal(slice);
     }
     if (flush != 0 && ctx->zs.avail_out > 0 && !eoc) {
       GPR_ASSERT(in->length == 0);
@@ -88,8 +88,8 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
             break;
           default:
             gpr_log(GPR_ERROR, "zlib error (%d)", r);
-            grpc_slice_unref_internal(&exec_ctx, slice_out);
-            grpc_exec_ctx_finish(&exec_ctx);
+            grpc_slice_unref_internal(slice_out);
+
             return false;
         }
       } else if (flush == Z_FINISH) {
@@ -104,8 +104,8 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
             break;
           default:
             gpr_log(GPR_ERROR, "zlib error (%d)", r);
-            grpc_slice_unref_internal(&exec_ctx, slice_out);
-            grpc_exec_ctx_finish(&exec_ctx);
+            grpc_slice_unref_internal(slice_out);
+
             return false;
         }
       }
@@ -114,14 +114,15 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
     if (ctx->zs.avail_out == 0) {
       grpc_slice_buffer_add(out, slice_out);
     } else if (ctx->zs.avail_out < slice_size) {
-      slice_out.data.refcounted.length -= ctx->zs.avail_out;
+      size_t len = GRPC_SLICE_LENGTH(slice_out);
+      GRPC_SLICE_SET_LENGTH(slice_out, len - ctx->zs.avail_out);
       grpc_slice_buffer_add(out, slice_out);
     } else {
-      grpc_slice_unref_internal(&exec_ctx, slice_out);
+      grpc_slice_unref_internal(slice_out);
     }
     max_output_size -= (slice_size - ctx->zs.avail_out);
   }
-  grpc_exec_ctx_finish(&exec_ctx);
+
   if (end_of_context) {
     *end_of_context = eoc;
   }

data/src/core/lib/compression/stream_compression_gzip.h

@@ -21,14 +21,6 @@
 
 #include "src/core/lib/compression/stream_compression.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_stream_compression_vtable grpc_stream_compression_gzip_vtable;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif

data/src/core/lib/compression/stream_compression_identity.h

@@ -21,15 +21,7 @@
 
 #include "src/core/lib/compression/stream_compression.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_stream_compression_vtable
     grpc_stream_compression_identity_vtable;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif

data/src/core/lib/debug/stats.cc

@@ -25,7 +25,7 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
 
-#include "src/core/lib/support/string.h"
+#include "src/core/lib/gpr/string.h"
 
 grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
@@ -62,9 +62,9 @@ void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
   }
 }
 
-int grpc_stats_histo_find_bucket_slow(grpc_exec_ctx* exec_ctx, int value,
-                                      const int* table, int table_size) {
-  GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS(exec_ctx);
+int grpc_stats_histo_find_bucket_slow(int value, const int* table,
+                                      int table_size) {
+  GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS();
   const int* const start = table;
   while (table_size > 0) {
     int step = table_size / 2;

data/src/core/lib/debug/stats.h

@@ -23,10 +23,6 @@
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_stats_data {
   gpr_atm counters[GRPC_STATS_COUNTER_COUNT];
   gpr_atm histograms[GRPC_STATS_HISTOGRAM_BUCKETS];
@@ -34,17 +30,15 @@ typedef struct grpc_stats_data {
 
 extern grpc_stats_data* grpc_stats_per_cpu_storage;
 
-#define GRPC_THREAD_STATS_DATA(exec_ctx) \
-  (&grpc_stats_per_cpu_storage[(exec_ctx)->starting_cpu])
+#define GRPC_THREAD_STATS_DATA() \
+  (&grpc_stats_per_cpu_storage[grpc_core::ExecCtx::Get()->starting_cpu()])
 
-#define GRPC_STATS_INC_COUNTER(exec_ctx, ctr) \
-  (gpr_atm_no_barrier_fetch_add(              \
-      &GRPC_THREAD_STATS_DATA((exec_ctx))->counters[(ctr)], 1))
+#define GRPC_STATS_INC_COUNTER(ctr) \
+  (gpr_atm_no_barrier_fetch_add(&GRPC_THREAD_STATS_DATA()->counters[(ctr)], 1))
 
-#define GRPC_STATS_INC_HISTOGRAM(exec_ctx, histogram, index) \
-  (gpr_atm_no_barrier_fetch_add(                             \
-      &GRPC_THREAD_STATS_DATA((exec_ctx))                    \
-           ->histograms[histogram##_FIRST_SLOT + (index)],   \
+#define GRPC_STATS_INC_HISTOGRAM(histogram, index)                             \
+  (gpr_atm_no_barrier_fetch_add(                                               \
+      &GRPC_THREAD_STATS_DATA()->histograms[histogram##_FIRST_SLOT + (index)], \
       1))
 
 void grpc_stats_init(void);
@@ -54,16 +48,12 @@ void grpc_stats_collect(grpc_stats_data* output);
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
                      grpc_stats_data* c);
 char* grpc_stats_data_as_json(const grpc_stats_data* data);
-int grpc_stats_histo_find_bucket_slow(grpc_exec_ctx* exec_ctx, int value,
-                                      const int* table, int table_size);
+int grpc_stats_histo_find_bucket_slow(int value, const int* table,
+                                      int table_size);
 double grpc_stats_histo_percentile(const grpc_stats_data* data,
                                    grpc_stats_histograms histogram,
                                    double percentile);
 size_t grpc_stats_histo_count(const grpc_stats_data* data,
                               grpc_stats_histograms histogram);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif

data/src/core/lib/debug/stats_data.cc

@@ -342,11 +342,10 @@ const uint8_t grpc_stats_table_7[102] = {
     42, 42, 43, 44, 44, 45, 46, 46, 47, 48, 48, 49, 49, 50, 50, 51, 51};
 const int grpc_stats_table_8[9] = {0, 1, 2, 4, 7, 13, 23, 39, 64};
 const uint8_t grpc_stats_table_9[9] = {0, 0, 1, 2, 2, 3, 4, 4, 5};
-void grpc_stats_inc_call_initial_size(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_call_initial_size(int value) {
   value = GPR_CLAMP(value, 0, 262144);
   if (value < 6) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
-                             value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE, value);
     return;
   }
   union {
@@ -359,19 +358,17 @@ void grpc_stats_inc_call_initial_size(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_1[((_val.uint - 4618441417868443648ull) >> 49)] + 6;
     _bkt.dbl = grpc_stats_table_0[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
-                             bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_0, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_CALL_INITIAL_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_0, 64));
 }
-void grpc_stats_inc_poll_events_returned(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_poll_events_returned(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 29) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, value);
     return;
   }
   union {
@@ -384,20 +381,17 @@ void grpc_stats_inc_poll_events_returned(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_3[((_val.uint - 4628855992006737920ull) >> 47)] + 29;
     _bkt.dbl = grpc_stats_table_2[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                           GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_2, 128));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_POLL_EVENTS_RETURNED,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_2, 128));
 }
-void grpc_stats_inc_tcp_write_size(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_tcp_write_size(int value) {
   value = GPR_CLAMP(value, 0, 16777216);
   if (value < 5) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
-                             value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE, value);
     return;
   }
   union {
@@ -410,19 +404,17 @@ void grpc_stats_inc_tcp_write_size(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_5[((_val.uint - 4617315517961601024ull) >> 50)] + 5;
     _bkt.dbl = grpc_stats_table_4[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
-                             bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_4, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_TCP_WRITE_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
-void grpc_stats_inc_tcp_write_iov_size(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_tcp_write_iov_size(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, value);
     return;
   }
   union {
@@ -435,19 +427,17 @@ void grpc_stats_inc_tcp_write_iov_size(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_7[((_val.uint - 4623507967449235456ull) >> 48)] + 13;
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_6, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_TCP_WRITE_IOV_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_tcp_read_size(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_tcp_read_size(int value) {
   value = GPR_CLAMP(value, 0, 16777216);
   if (value < 5) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
-                             value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_SIZE, value);
     return;
   }
   union {
@@ -460,19 +450,17 @@ void grpc_stats_inc_tcp_read_size(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_5[((_val.uint - 4617315517961601024ull) >> 50)] + 5;
     _bkt.dbl = grpc_stats_table_4[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
-                             bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_SIZE, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_4, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_TCP_READ_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
-void grpc_stats_inc_tcp_read_offer(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_tcp_read_offer(int value) {
   value = GPR_CLAMP(value, 0, 16777216);
   if (value < 5) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
-                             value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER, value);
     return;
   }
   union {
@@ -485,20 +473,18 @@ void grpc_stats_inc_tcp_read_offer(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_5[((_val.uint - 4617315517961601024ull) >> 50)] + 5;
     _bkt.dbl = grpc_stats_table_4[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
-                             bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_4, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_TCP_READ_OFFER,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
-void grpc_stats_inc_tcp_read_offer_iov_size(grpc_exec_ctx* exec_ctx,
-                                            int value) {
+void grpc_stats_inc_tcp_read_offer_iov_size(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
+                             value);
     return;
   }
   union {
@@ -511,21 +497,19 @@ void grpc_stats_inc_tcp_read_offer_iov_size(grpc_exec_ctx* exec_ctx,
         grpc_stats_table_7[((_val.uint - 4623507967449235456ull) >> 48)] + 13;
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
+                             bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                           GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_6, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_TCP_READ_OFFER_IOV_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_http2_send_message_size(grpc_exec_ctx* exec_ctx,
-                                            int value) {
+void grpc_stats_inc_http2_send_message_size(int value) {
   value = GPR_CLAMP(value, 0, 16777216);
   if (value < 5) {
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
+                             value);
     return;
   }
   union {
@@ -538,22 +522,19 @@ void grpc_stats_inc_http2_send_message_size(grpc_exec_ctx* exec_ctx,
         grpc_stats_table_5[((_val.uint - 4617315517961601024ull) >> 50)] + 5;
     _bkt.dbl = grpc_stats_table_4[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
+                             bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                           GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_4, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_SIZE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_4, 64));
 }
-void grpc_stats_inc_http2_send_initial_metadata_per_write(
-    grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_http2_send_initial_metadata_per_write(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE,
-        value);
+        GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE, value);
     return;
   }
   union {
@@ -567,21 +548,18 @@ void grpc_stats_inc_http2_send_initial_metadata_per_write(
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
     GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE,
-        bucket);
+        GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE, bucket);
     return;
   }
   GRPC_STATS_INC_HISTOGRAM(
-      (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE,
-      grpc_stats_histo_find_bucket_slow((exec_ctx), value, grpc_stats_table_6,
-                                        64));
+      GRPC_STATS_HISTOGRAM_HTTP2_SEND_INITIAL_METADATA_PER_WRITE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_http2_send_message_per_write(grpc_exec_ctx* exec_ctx,
-                                                 int value) {
+void grpc_stats_inc_http2_send_message_per_write(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
+                             value);
     return;
   }
   union {
@@ -594,22 +572,19 @@ void grpc_stats_inc_http2_send_message_per_write(grpc_exec_ctx* exec_ctx,
         grpc_stats_table_7[((_val.uint - 4623507967449235456ull) >> 48)] + 13;
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
+                             bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                           GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_6, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_http2_send_trailing_metadata_per_write(
-    grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_http2_send_trailing_metadata_per_write(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
     GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE,
-        value);
+        GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE, value);
     return;
   }
   union {
@@ -623,21 +598,18 @@ void grpc_stats_inc_http2_send_trailing_metadata_per_write(
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
     GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE,
-        bucket);
+        GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE, bucket);
     return;
   }
   GRPC_STATS_INC_HISTOGRAM(
-      (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE,
-      grpc_stats_histo_find_bucket_slow((exec_ctx), value, grpc_stats_table_6,
-                                        64));
+      GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_http2_send_flowctl_per_write(grpc_exec_ctx* exec_ctx,
-                                                 int value) {
+void grpc_stats_inc_http2_send_flowctl_per_write(int value) {
   value = GPR_CLAMP(value, 0, 1024);
   if (value < 13) {
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
+                             value);
     return;
   }
   union {
@@ -650,20 +622,18 @@ void grpc_stats_inc_http2_send_flowctl_per_write(grpc_exec_ctx* exec_ctx,
         grpc_stats_table_7[((_val.uint - 4623507967449235456ull) >> 48)] + 13;
     _bkt.dbl = grpc_stats_table_6[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM(
-        (exec_ctx), GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
+                             bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                           GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_6, 64));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_6, 64));
 }
-void grpc_stats_inc_server_cqs_checked(grpc_exec_ctx* exec_ctx, int value) {
+void grpc_stats_inc_server_cqs_checked(int value) {
   value = GPR_CLAMP(value, 0, 64);
   if (value < 3) {
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, value);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, value);
     return;
   }
   union {
@@ -676,13 +646,12 @@ void grpc_stats_inc_server_cqs_checked(grpc_exec_ctx* exec_ctx, int value) {
         grpc_stats_table_9[((_val.uint - 4613937818241073152ull) >> 51)] + 3;
     _bkt.dbl = grpc_stats_table_8[bucket];
     bucket -= (_val.uint < _bkt.uint);
-    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-                             GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, bucket);
+    GRPC_STATS_INC_HISTOGRAM(GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, bucket);
     return;
   }
-  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED,
-                           grpc_stats_histo_find_bucket_slow(
-                               (exec_ctx), value, grpc_stats_table_8, 8));
+  GRPC_STATS_INC_HISTOGRAM(
+      GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED,
+      grpc_stats_histo_find_bucket_slow(value, grpc_stats_table_8, 8));
 }
 const int grpc_stats_histo_buckets[13] = {64, 128, 64, 64, 64, 64, 64,
                                           64, 64,  64, 64, 64, 8};
@@ -694,7 +663,7 @@ const int* const grpc_stats_histo_bucket_boundaries[13] = {
     grpc_stats_table_6, grpc_stats_table_4, grpc_stats_table_6,
     grpc_stats_table_6, grpc_stats_table_6, grpc_stats_table_6,
     grpc_stats_table_8};
-void (*const grpc_stats_inc_histogram[13])(grpc_exec_ctx* exec_ctx, int x) = {
+void (*const grpc_stats_inc_histogram[13])(int x) = {
     grpc_stats_inc_call_initial_size,
     grpc_stats_inc_poll_events_returned,
     grpc_stats_inc_tcp_write_size,