Merge pull request #12672 from ctiller/hpack_stats

Add HPACK stats

src/core/ext/transport/chttp2/transport/hpack_encoder.c

@@ -33,6 +33,7 @@
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_table.h"
 #include "src/core/ext/transport/chttp2/transport/varint.h"
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/metadata.h"
@@ -271,8 +272,10 @@ static void add_elem(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   }
 }
 
-static void emit_indexed(grpc_chttp2_hpack_compressor *c, uint32_t elem_index,
+static void emit_indexed(grpc_exec_ctx *exec_ctx,
+                         grpc_chttp2_hpack_compressor *c, uint32_t elem_index,
                          framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_INDEXED(exec_ctx);
   uint32_t len = GRPC_CHTTP2_VARINT_LENGTH(elem_index, 1);
   GRPC_CHTTP2_WRITE_VARINT(elem_index, 1, 0x80, add_tiny_header_data(st, len),
                            len);
@@ -284,15 +287,18 @@ typedef struct {
   bool insert_null_before_wire_value;
 } wire_value;
 
-static wire_value get_wire_value(grpc_mdelem elem, bool true_binary_enabled) {
+static wire_value get_wire_value(grpc_exec_ctx *exec_ctx, grpc_mdelem elem,
+                                 bool true_binary_enabled) {
   wire_value wire_val;
   if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
     if (true_binary_enabled) {
+      GRPC_STATS_INC_HPACK_SEND_BINARY(exec_ctx);
       wire_val.huffman_prefix = 0x00;
       wire_val.insert_null_before_wire_value = true;
       wire_val.data = grpc_slice_ref_internal(GRPC_MDVALUE(elem));
 
     } else {
+      GRPC_STATS_INC_HPACK_SEND_BINARY_BASE64(exec_ctx);
       wire_val.huffman_prefix = 0x80;
       wire_val.insert_null_before_wire_value = false;
       wire_val.data =
@@ -300,6 +306,7 @@ static wire_value get_wire_value(grpc_mdelem elem, bool true_binary_enabled) {
     }
   } else {
     /* TODO(ctiller): opportunistically compress non-binary headers */
+    GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
     wire_val.huffman_prefix = 0x00;
     wire_val.insert_null_before_wire_value = false;
     wire_val.data = grpc_slice_ref_internal(GRPC_MDVALUE(elem));
@@ -316,11 +323,14 @@ static void add_wire_value(framer_state *st, wire_value v) {
   add_header_data(st, v.data);
 }
 
-static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_incidx(grpc_exec_ctx *exec_ctx,
+                               grpc_chttp2_hpack_compressor *c,
                                uint32_t key_index, grpc_mdelem elem,
                                framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX(exec_ctx);
   uint32_t len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2);
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   size_t len_val = wire_value_length(value);
   uint32_t len_val_len;
   GPR_ASSERT(len_val <= UINT32_MAX);
@@ -332,11 +342,14 @@ static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_noidx(grpc_exec_ctx *exec_ctx,
+                              grpc_chttp2_hpack_compressor *c,
                               uint32_t key_index, grpc_mdelem elem,
                               framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX(exec_ctx);
   uint32_t len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   size_t len_val = wire_value_length(value);
   uint32_t len_val_len;
   GPR_ASSERT(len_val <= UINT32_MAX);
@@ -348,10 +361,14 @@ static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
+                                 grpc_chttp2_hpack_compressor *c,
                                  grpc_mdelem elem, framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V(exec_ctx);
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
   uint32_t len_key = (uint32_t)GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   uint32_t len_val = (uint32_t)wire_value_length(value);
   uint32_t len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
   uint32_t len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
@@ -366,10 +383,14 @@ static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_noidx_v(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_noidx_v(grpc_exec_ctx *exec_ctx,
+                                grpc_chttp2_hpack_compressor *c,
                                 grpc_mdelem elem, framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V(exec_ctx);
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
   uint32_t len_key = (uint32_t)GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   uint32_t len_val = (uint32_t)wire_value_length(value);
   uint32_t len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
   uint32_t len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
@@ -422,7 +443,7 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
     gpr_free(v);
   }
   if (!GRPC_MDELEM_IS_INTERNED(elem)) {
-    emit_lithdr_noidx_v(c, elem, st);
+    emit_lithdr_noidx_v(exec_ctx, c, elem, st);
     return;
   }
 
@@ -444,16 +465,16 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   if (grpc_mdelem_eq(c->entries_elems[HASH_FRAGMENT_2(elem_hash)], elem) &&
       c->indices_elems[HASH_FRAGMENT_2(elem_hash)] > c->tail_remote_index) {
     /* HIT: complete element (first cuckoo hash) */
-    emit_indexed(c, dynidx(c, c->indices_elems[HASH_FRAGMENT_2(elem_hash)]),
-                 st);
+    emit_indexed(exec_ctx, c,
+                 dynidx(c, c->indices_elems[HASH_FRAGMENT_2(elem_hash)]), st);
     return;
   }
 
   if (grpc_mdelem_eq(c->entries_elems[HASH_FRAGMENT_3(elem_hash)], elem) &&
       c->indices_elems[HASH_FRAGMENT_3(elem_hash)] > c->tail_remote_index) {
     /* HIT: complete element (second cuckoo hash) */
-    emit_indexed(c, dynidx(c, c->indices_elems[HASH_FRAGMENT_3(elem_hash)]),
-                 st);
+    emit_indexed(exec_ctx, c,
+                 dynidx(c, c->indices_elems[HASH_FRAGMENT_3(elem_hash)]), st);
     return;
   }
 
@@ -471,11 +492,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
       indices_key > c->tail_remote_index) {
     /* HIT: key (first cuckoo hash) */
     if (should_add_elem) {
-      emit_lithdr_incidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_incidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       add_elem(exec_ctx, c, elem);
       return;
     } else {
-      emit_lithdr_noidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_noidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       return;
     }
     GPR_UNREACHABLE_CODE(return );
@@ -487,11 +508,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
       indices_key > c->tail_remote_index) {
     /* HIT: key (first cuckoo hash) */
     if (should_add_elem) {
-      emit_lithdr_incidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_incidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       add_elem(exec_ctx, c, elem);
       return;
     } else {
-      emit_lithdr_noidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_noidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       return;
     }
     GPR_UNREACHABLE_CODE(return );
@@ -500,11 +521,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   /* no elem, key in the table... fall back to literal emission */
 
   if (should_add_elem) {
-    emit_lithdr_incidx_v(c, elem, st);
+    emit_lithdr_incidx_v(exec_ctx, c, elem, st);
     add_elem(exec_ctx, c, elem);
     return;
   } else {
-    emit_lithdr_noidx_v(c, elem, st);
+    emit_lithdr_noidx_v(exec_ctx, c, elem, st);
     return;
   }
   GPR_UNREACHABLE_CODE(return );

src/core/ext/transport/chttp2/transport/hpack_parser.c

@@ -30,6 +30,7 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/support/string.h"
@@ -777,8 +778,7 @@ static grpc_error *parse_stream_dep0(grpc_exec_ctx *exec_ctx,
   return parse_stream_dep1(exec_ctx, p, cur + 1, end);
 }
 
-/* emit an indexed field; for now just logs it to console; jumps to
-   begin the next field on completion */
+/* emit an indexed field; jumps to begin the next field on completion */
 static grpc_error *finish_indexed_field(grpc_exec_ctx *exec_ctx,
                                         grpc_chttp2_hpack_parser *p,
                                         const uint8_t *cur,
@@ -792,6 +792,7 @@ static grpc_error *finish_indexed_field(grpc_exec_ctx *exec_ctx,
         GRPC_ERROR_INT_SIZE, (intptr_t)p->table.num_ents);
   }
   GRPC_MDELEM_REF(md);
+  GRPC_STATS_INC_HPACK_RECV_INDEXED(exec_ctx);
   grpc_error *err = on_hdr(exec_ctx, p, md, 0);
   if (err != GRPC_ERROR_NONE) return err;
   return parse_begin(exec_ctx, p, cur, end);
@@ -820,14 +821,14 @@ static grpc_error *parse_indexed_field_x(grpc_exec_ctx *exec_ctx,
   return parse_value0(exec_ctx, p, cur + 1, end);
 }
 
-/* finish a literal header with incremental indexing: just log, and jump to '
-   begin */
+/* finish a literal header with incremental indexing */
 static grpc_error *finish_lithdr_incidx(grpc_exec_ctx *exec_ctx,
                                         grpc_chttp2_hpack_parser *p,
                                         const uint8_t *cur,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -842,6 +843,7 @@ static grpc_error *finish_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -898,6 +900,7 @@ static grpc_error *finish_lithdr_notidx(grpc_exec_ctx *exec_ctx,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -912,6 +915,7 @@ static grpc_error *finish_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -968,6 +972,7 @@ static grpc_error *finish_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -982,6 +987,7 @@ static grpc_error *finish_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -1310,9 +1316,11 @@ static grpc_error *append_string(grpc_exec_ctx *exec_ctx,
         /* 'true-binary' case */
         ++cur;
         p->binary = NOT_BINARY;
+        GRPC_STATS_INC_HPACK_RECV_BINARY(exec_ctx);
         append_bytes(str, cur, (size_t)(end - cur));
         return GRPC_ERROR_NONE;
       }
+      GRPC_STATS_INC_HPACK_RECV_BINARY_BASE64(exec_ctx);
     /* fallthrough */
     b64_byte0:
     case B64_BYTE0:
@@ -1510,6 +1518,7 @@ static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
                                       grpc_chttp2_hpack_parser_string *str) {
   if (!p->huff && binary == NOT_BINARY && (end - cur) >= (intptr_t)p->strlen &&
       p->current_slice_refcount != NULL) {
+    GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx);
     str->copied = false;
     str->data.referenced.refcount = p->current_slice_refcount;
     str->data.referenced.data.refcounted.bytes = (uint8_t *)cur;
@@ -1523,6 +1532,20 @@ static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
   p->parsing.str = str;
   p->huff_state = 0;
   p->binary = binary;
+  switch (p->binary) {
+    case NOT_BINARY:
+      if (p->huff) {
+        GRPC_STATS_INC_HPACK_RECV_HUFFMAN(exec_ctx);
+      } else {
+        GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx);
+      }
+      break;
+    case BINARY_BEGIN:
+      /* stats incremented later: don't know true binary or not */
+      break;
+    default:
+      abort();
+  }
   return parse_string(exec_ctx, p, cur, end);
 }
 

src/core/lib/debug/stats_data.c

@@ -77,6 +77,28 @@ const char *grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "http2_initiate_write_due_to_transport_flow_control_unstalled",
     "http2_initiate_write_due_to_ping_response",
     "http2_initiate_write_due_to_force_rst_stream",
+    "hpack_recv_indexed",
+    "hpack_recv_lithdr_incidx",
+    "hpack_recv_lithdr_incidx_v",
+    "hpack_recv_lithdr_notidx",
+    "hpack_recv_lithdr_notidx_v",
+    "hpack_recv_lithdr_nvridx",
+    "hpack_recv_lithdr_nvridx_v",
+    "hpack_recv_uncompressed",
+    "hpack_recv_huffman",
+    "hpack_recv_binary",
+    "hpack_recv_binary_base64",
+    "hpack_send_indexed",
+    "hpack_send_lithdr_incidx",
+    "hpack_send_lithdr_incidx_v",
+    "hpack_send_lithdr_notidx",
+    "hpack_send_lithdr_notidx_v",
+    "hpack_send_lithdr_nvridx",
+    "hpack_send_lithdr_nvridx_v",
+    "hpack_send_uncompressed",
+    "hpack_send_huffman",
+    "hpack_send_binary",
+    "hpack_send_binary_base64",
     "combiner_locks_initiated",
     "combiner_locks_scheduled_items",
     "combiner_locks_scheduled_final_items",
@@ -157,6 +179,32 @@ const char *grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
     "'transport_flow_control_unstalled'",
     "Number of HTTP2 writes initiated due to 'ping_response'",
     "Number of HTTP2 writes initiated due to 'force_rst_stream'",
+    "Number of HPACK indexed fields received",
+    "Number of HPACK literal headers received with incremental indexing",
+    "Number of HPACK literal headers received with incremental indexing and "
+    "literal keys",
+    "Number of HPACK literal headers received with no indexing",
+    "Number of HPACK literal headers received with no indexing and literal "
+    "keys",
+    "Number of HPACK literal headers received with never-indexing",
+    "Number of HPACK literal headers received with never-indexing and literal "
+    "keys",
+    "Number of uncompressed strings received in metadata",
+    "Number of huffman encoded strings received in metadata",
+    "Number of binary strings received in metadata",
+    "Number of binary strings received encoded in base64 in metadata",
+    "Number of HPACK indexed fields sent",
+    "Number of HPACK literal headers sent with incremental indexing",
+    "Number of HPACK literal headers sent with incremental indexing and "
+    "literal keys",
+    "Number of HPACK literal headers sent with no indexing",
+    "Number of HPACK literal headers sent with no indexing and literal keys",
+    "Number of HPACK literal headers sent with never-indexing",
+    "Number of HPACK literal headers sent with never-indexing and literal keys",
+    "Number of uncompressed strings sent in metadata",
+    "Number of huffman encoded strings sent in metadata",
+    "Number of binary strings received in metadata",
+    "Number of binary strings received encoded in base64 in metadata",
     "Number of combiner lock entries by process (first items queued to a "
     "combiner)",
     "Number of items scheduled against combiner locks",

src/core/lib/debug/stats_data.h

@@ -79,6 +79,28 @@ typedef enum {
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_TRANSPORT_FLOW_CONTROL_UNSTALLED,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_PING_RESPONSE,
   GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FORCE_RST_STREAM,
+  GRPC_STATS_COUNTER_HPACK_RECV_INDEXED,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_INCIDX,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_INCIDX_V,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NOTIDX,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NOTIDX_V,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NVRIDX,
+  GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NVRIDX_V,
+  GRPC_STATS_COUNTER_HPACK_RECV_UNCOMPRESSED,
+  GRPC_STATS_COUNTER_HPACK_RECV_HUFFMAN,
+  GRPC_STATS_COUNTER_HPACK_RECV_BINARY,
+  GRPC_STATS_COUNTER_HPACK_RECV_BINARY_BASE64,
+  GRPC_STATS_COUNTER_HPACK_SEND_INDEXED,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_INCIDX,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_INCIDX_V,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NOTIDX,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NOTIDX_V,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NVRIDX,
+  GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NVRIDX_V,
+  GRPC_STATS_COUNTER_HPACK_SEND_UNCOMPRESSED,
+  GRPC_STATS_COUNTER_HPACK_SEND_HUFFMAN,
+  GRPC_STATS_COUNTER_HPACK_SEND_BINARY,
+  GRPC_STATS_COUNTER_HPACK_SEND_BINARY_BASE64,
   GRPC_STATS_COUNTER_COMBINER_LOCKS_INITIATED,
   GRPC_STATS_COUNTER_COMBINER_LOCKS_SCHEDULED_ITEMS,
   GRPC_STATS_COUNTER_COMBINER_LOCKS_SCHEDULED_FINAL_ITEMS,
@@ -309,6 +331,64 @@ typedef enum {
   GRPC_STATS_INC_COUNTER(                                                     \
       (exec_ctx),                                                             \
       GRPC_STATS_COUNTER_HTTP2_INITIATE_WRITE_DUE_TO_FORCE_RST_STREAM)
+#define GRPC_STATS_INC_HPACK_RECV_INDEXED(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_RECV_INDEXED)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_INCIDX)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_INCIDX_V)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NOTIDX)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NOTIDX_V)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NVRIDX)
+#define GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_RECV_LITHDR_NVRIDX_V)
+#define GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_RECV_UNCOMPRESSED)
+#define GRPC_STATS_INC_HPACK_RECV_HUFFMAN(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_RECV_HUFFMAN)
+#define GRPC_STATS_INC_HPACK_RECV_BINARY(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_RECV_BINARY)
+#define GRPC_STATS_INC_HPACK_RECV_BINARY_BASE64(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_RECV_BINARY_BASE64)
+#define GRPC_STATS_INC_HPACK_SEND_INDEXED(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_SEND_INDEXED)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_INCIDX)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_INCIDX_V)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NOTIDX)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NOTIDX_V)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_NVRIDX(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NVRIDX)
+#define GRPC_STATS_INC_HPACK_SEND_LITHDR_NVRIDX_V(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                        \
+                         GRPC_STATS_COUNTER_HPACK_SEND_LITHDR_NVRIDX_V)
+#define GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_SEND_UNCOMPRESSED)
+#define GRPC_STATS_INC_HPACK_SEND_HUFFMAN(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_SEND_HUFFMAN)
+#define GRPC_STATS_INC_HPACK_SEND_BINARY(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_HPACK_SEND_BINARY)
+#define GRPC_STATS_INC_HPACK_SEND_BINARY_BASE64(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                      \
+                         GRPC_STATS_COUNTER_HPACK_SEND_BINARY_BASE64)
 #define GRPC_STATS_INC_COMBINER_LOCKS_INITIATED(exec_ctx) \
   GRPC_STATS_INC_COUNTER((exec_ctx),                      \
                          GRPC_STATS_COUNTER_COMBINER_LOCKS_INITIATED)

src/core/lib/debug/stats_data.yaml

@@ -189,6 +189,50 @@
   doc: Number of HTTP2 writes initiated due to 'ping_response'
 - counter: http2_initiate_write_due_to_force_rst_stream
   doc: Number of HTTP2 writes initiated due to 'force_rst_stream'
+- counter: hpack_recv_indexed
+  doc: Number of HPACK indexed fields received
+- counter: hpack_recv_lithdr_incidx
+  doc: Number of HPACK literal headers received with incremental indexing
+- counter: hpack_recv_lithdr_incidx_v
+  doc: Number of HPACK literal headers received with incremental indexing and literal keys
+- counter: hpack_recv_lithdr_notidx
+  doc: Number of HPACK literal headers received with no indexing
+- counter: hpack_recv_lithdr_notidx_v
+  doc: Number of HPACK literal headers received with no indexing and literal keys
+- counter: hpack_recv_lithdr_nvridx
+  doc: Number of HPACK literal headers received with never-indexing
+- counter: hpack_recv_lithdr_nvridx_v
+  doc: Number of HPACK literal headers received with never-indexing and literal keys
+- counter: hpack_recv_uncompressed
+  doc: Number of uncompressed strings received in metadata
+- counter: hpack_recv_huffman
+  doc: Number of huffman encoded strings received in metadata
+- counter: hpack_recv_binary
+  doc: Number of binary strings received in metadata
+- counter: hpack_recv_binary_base64
+  doc: Number of binary strings received encoded in base64 in metadata
+- counter: hpack_send_indexed
+  doc: Number of HPACK indexed fields sent
+- counter: hpack_send_lithdr_incidx
+  doc: Number of HPACK literal headers sent with incremental indexing
+- counter: hpack_send_lithdr_incidx_v
+  doc: Number of HPACK literal headers sent with incremental indexing and literal keys
+- counter: hpack_send_lithdr_notidx
+  doc: Number of HPACK literal headers sent with no indexing
+- counter: hpack_send_lithdr_notidx_v
+  doc: Number of HPACK literal headers sent with no indexing and literal keys
+- counter: hpack_send_lithdr_nvridx
+  doc: Number of HPACK literal headers sent with never-indexing
+- counter: hpack_send_lithdr_nvridx_v
+  doc: Number of HPACK literal headers sent with never-indexing and literal keys
+- counter: hpack_send_uncompressed
+  doc: Number of uncompressed strings sent in metadata
+- counter: hpack_send_huffman
+  doc: Number of huffman encoded strings sent in metadata
+- counter: hpack_send_binary
+  doc: Number of binary strings received in metadata
+- counter: hpack_send_binary_base64
+  doc: Number of binary strings received encoded in base64 in metadata
 # combiner locks
 - counter: combiner_locks_initiated
   doc: Number of combiner lock entries by process

src/core/lib/debug/stats_data_bq_schema.sql

@@ -52,6 +52,28 @@ http2_initiate_write_due_to_keepalive_ping_per_iteration:FLOAT,
 http2_initiate_write_due_to_transport_flow_control_unstalled_per_iteration:FLOAT,
 http2_initiate_write_due_to_ping_response_per_iteration:FLOAT,
 http2_initiate_write_due_to_force_rst_stream_per_iteration:FLOAT,
+hpack_recv_indexed_per_iteration:FLOAT,
+hpack_recv_lithdr_incidx_per_iteration:FLOAT,
+hpack_recv_lithdr_incidx_v_per_iteration:FLOAT,
+hpack_recv_lithdr_notidx_per_iteration:FLOAT,
+hpack_recv_lithdr_notidx_v_per_iteration:FLOAT,
+hpack_recv_lithdr_nvridx_per_iteration:FLOAT,
+hpack_recv_lithdr_nvridx_v_per_iteration:FLOAT,
+hpack_recv_uncompressed_per_iteration:FLOAT,
+hpack_recv_huffman_per_iteration:FLOAT,
+hpack_recv_binary_per_iteration:FLOAT,
+hpack_recv_binary_base64_per_iteration:FLOAT,
+hpack_send_indexed_per_iteration:FLOAT,
+hpack_send_lithdr_incidx_per_iteration:FLOAT,
+hpack_send_lithdr_incidx_v_per_iteration:FLOAT,
+hpack_send_lithdr_notidx_per_iteration:FLOAT,
+hpack_send_lithdr_notidx_v_per_iteration:FLOAT,
+hpack_send_lithdr_nvridx_per_iteration:FLOAT,
+hpack_send_lithdr_nvridx_v_per_iteration:FLOAT,
+hpack_send_uncompressed_per_iteration:FLOAT,
+hpack_send_huffman_per_iteration:FLOAT,
+hpack_send_binary_per_iteration:FLOAT,
+hpack_send_binary_base64_per_iteration:FLOAT,
 combiner_locks_initiated_per_iteration:FLOAT,
 combiner_locks_scheduled_items_per_iteration:FLOAT,
 combiner_locks_scheduled_final_items_per_iteration:FLOAT,

tools/run_tests/performance/massage_qps_stats.py

@@ -74,6 +74,28 @@ def massage_qps_stats(scenario_result):
     stats["core_http2_initiate_write_due_to_transport_flow_control_unstalled"] = massage_qps_stats_helpers.counter(core_stats, "http2_initiate_write_due_to_transport_flow_control_unstalled")
     stats["core_http2_initiate_write_due_to_ping_response"] = massage_qps_stats_helpers.counter(core_stats, "http2_initiate_write_due_to_ping_response")
     stats["core_http2_initiate_write_due_to_force_rst_stream"] = massage_qps_stats_helpers.counter(core_stats, "http2_initiate_write_due_to_force_rst_stream")
+    stats["core_hpack_recv_indexed"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_indexed")
+    stats["core_hpack_recv_lithdr_incidx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_incidx")
+    stats["core_hpack_recv_lithdr_incidx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_incidx_v")
+    stats["core_hpack_recv_lithdr_notidx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_notidx")
+    stats["core_hpack_recv_lithdr_notidx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_notidx_v")
+    stats["core_hpack_recv_lithdr_nvridx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_nvridx")
+    stats["core_hpack_recv_lithdr_nvridx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_lithdr_nvridx_v")
+    stats["core_hpack_recv_uncompressed"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_uncompressed")
+    stats["core_hpack_recv_huffman"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_huffman")
+    stats["core_hpack_recv_binary"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_binary")
+    stats["core_hpack_recv_binary_base64"] = massage_qps_stats_helpers.counter(core_stats, "hpack_recv_binary_base64")
+    stats["core_hpack_send_indexed"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_indexed")
+    stats["core_hpack_send_lithdr_incidx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_incidx")
+    stats["core_hpack_send_lithdr_incidx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_incidx_v")
+    stats["core_hpack_send_lithdr_notidx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_notidx")
+    stats["core_hpack_send_lithdr_notidx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_notidx_v")
+    stats["core_hpack_send_lithdr_nvridx"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_nvridx")
+    stats["core_hpack_send_lithdr_nvridx_v"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_lithdr_nvridx_v")
+    stats["core_hpack_send_uncompressed"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_uncompressed")
+    stats["core_hpack_send_huffman"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_huffman")
+    stats["core_hpack_send_binary"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_binary")
+    stats["core_hpack_send_binary_base64"] = massage_qps_stats_helpers.counter(core_stats, "hpack_send_binary_base64")
     stats["core_combiner_locks_initiated"] = massage_qps_stats_helpers.counter(core_stats, "combiner_locks_initiated")
     stats["core_combiner_locks_scheduled_items"] = massage_qps_stats_helpers.counter(core_stats, "combiner_locks_scheduled_items")
     stats["core_combiner_locks_scheduled_final_items"] = massage_qps_stats_helpers.counter(core_stats, "combiner_locks_scheduled_final_items")

tools/run_tests/performance/scenario_result_schema.json

@@ -380,6 +380,116 @@
         "name": "core_http2_initiate_write_due_to_force_rst_stream", 
         "type": "INTEGER"
       }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_indexed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_incidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_incidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_notidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_notidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_nvridx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_nvridx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_uncompressed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_huffman", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_binary", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_binary_base64", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_indexed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_incidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_incidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_notidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_notidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_nvridx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_nvridx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_uncompressed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_huffman", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_binary", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_binary_base64", 
+        "type": "INTEGER"
+      }, 
       {
         "mode": "NULLABLE", 
         "name": "core_combiner_locks_initiated", 
@@ -1097,6 +1207,116 @@
         "name": "core_http2_initiate_write_due_to_force_rst_stream", 
         "type": "INTEGER"
       }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_indexed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_incidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_incidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_notidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_notidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_nvridx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_lithdr_nvridx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_uncompressed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_huffman", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_binary", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_recv_binary_base64", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_indexed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_incidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_incidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_notidx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_notidx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_nvridx", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_lithdr_nvridx_v", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_uncompressed", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_huffman", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_binary", 
+        "type": "INTEGER"
+      }, 
+      {
+        "mode": "NULLABLE", 
+        "name": "core_hpack_send_binary_base64", 
+        "type": "INTEGER"
+      }, 
       {
         "mode": "NULLABLE", 
         "name": "core_combiner_locks_initiated",