自学教程：C++ GPR_TIMER_END函数代码示例

static void tcp_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,                      grpc_slice_buffer *buf, grpc_closure *cb) {  grpc_tcp *tcp = (grpc_tcp *)ep;  grpc_error *error = GRPC_ERROR_NONE;  if (grpc_tcp_trace) {    size_t i;    for (i = 0; i < buf->count; i++) {      char *data =          grpc_dump_slice(buf->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string, data);      gpr_free(data);    }  }  GPR_TIMER_BEGIN("tcp_write", 0);  GPR_ASSERT(tcp->write_cb == NULL);  if (buf->length == 0) {    GPR_TIMER_END("tcp_write", 0);    grpc_exec_ctx_sched(exec_ctx, cb,                        grpc_fd_is_shutdown(tcp->em_fd)                            ? tcp_annotate_error(GRPC_ERROR_CREATE("EOF"), tcp)                            : GRPC_ERROR_NONE,                        NULL);    return;  }  tcp->outgoing_buffer = buf;  tcp->outgoing_slice_idx = 0;  tcp->outgoing_byte_idx = 0;  if (!tcp_flush(tcp, &error)) {    TCP_REF(tcp, "write");    tcp->write_cb = cb;    if (grpc_tcp_trace) {      gpr_log(GPR_DEBUG, "write: delayed");    }    grpc_fd_notify_on_write(exec_ctx, tcp->em_fd, &tcp->write_closure);  } else {    if (grpc_tcp_trace) {      const char *str = grpc_error_string(error);      gpr_log(GPR_DEBUG, "write: %s", str);      grpc_error_free_string(str);    }    grpc_exec_ctx_sched(exec_ctx, cb, error, NULL);  }  GPR_TIMER_END("tcp_write", 0);}

static grpc_mdelem *recv_common_filter(grpc_call *call, grpc_mdelem *elem) {  if (elem->key == grpc_channel_get_status_string(call->channel)) {    GPR_TIMER_BEGIN("status", 0);    set_status_code(call, STATUS_FROM_WIRE, decode_status(elem));    GPR_TIMER_END("status", 0);    return NULL;  } else if (elem->key == grpc_channel_get_message_string(call->channel)) {    GPR_TIMER_BEGIN("status-details", 0);    set_status_details(call, STATUS_FROM_WIRE, GRPC_MDSTR_REF(elem->value));    GPR_TIMER_END("status-details", 0);    return NULL;  }  return elem;}

static void on_trailing_header(void *tp, grpc_mdelem *md) {  grpc_chttp2_transport_parsing *transport_parsing = tp;  grpc_chttp2_stream_parsing *stream_parsing =      transport_parsing->incoming_stream;  GPR_TIMER_BEGIN("on_trailing_header", 0);  GPR_ASSERT(stream_parsing);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", stream_parsing->id,      transport_parsing->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    stream_parsing->seen_error = 1;  }  grpc_chttp2_incoming_metadata_buffer_add(&stream_parsing->metadata_buffer[1],                                           md);  grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing);  GPR_TIMER_END("on_trailing_header", 0);}

static void grow_shard(slice_shard *shard) {  size_t capacity = shard->capacity * 2;  size_t i;  interned_slice_refcount **strtab;  interned_slice_refcount *s, *next;  GPR_TIMER_BEGIN("grow_strtab", 0);  strtab = (interned_slice_refcount **)gpr_zalloc(      sizeof(interned_slice_refcount *) * capacity);  for (i = 0; i < shard->capacity; i++) {    for (s = shard->strs[i]; s; s = next) {      size_t idx = TABLE_IDX(s->hash, capacity);      next = s->bucket_next;      s->bucket_next = strtab[idx];      strtab[idx] = s;    }  }  gpr_free(shard->strs);  shard->strs = strtab;  shard->capacity = capacity;  GPR_TIMER_END("grow_strtab", 0);}

static void on_initial_header(grpc_exec_ctx *exec_ctx, void *tp,                              grpc_mdelem *md) {  grpc_chttp2_transport *t = tp;  grpc_chttp2_stream *s = t->incoming_stream;  GPR_TIMER_BEGIN("on_initial_header", 0);  GPR_ASSERT(s != NULL);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", s->id, t->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    s->seen_error = true;  }  if (md->key == GRPC_MDSTR_GRPC_TIMEOUT) {    gpr_timespec *cached_timeout = grpc_mdelem_get_user_data(md, free_timeout);    if (!cached_timeout) {      /* not already parsed: parse it now, and store the result away */      cached_timeout = gpr_malloc(sizeof(gpr_timespec));      if (!grpc_http2_decode_timeout(grpc_mdstr_as_c_string(md->value),                                     cached_timeout)) {        gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'",                grpc_mdstr_as_c_string(md->value));        *cached_timeout = gpr_inf_future(GPR_TIMESPAN);      }      grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);    }    grpc_chttp2_incoming_metadata_buffer_set_deadline(        &s->metadata_buffer[0],        gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), *cached_timeout));    GRPC_MDELEM_UNREF(md);  } else {    const size_t new_size = s->metadata_buffer[0].size + GRPC_MDELEM_LENGTH(md);    const size_t metadata_size_limit =        t->settings[GRPC_ACKED_SETTINGS]                   [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];    if (new_size > metadata_size_limit) {      gpr_log(GPR_DEBUG,              "received initial metadata size exceeds limit (%" PRIuPTR              " vs. %" PRIuPTR ")",              new_size, metadata_size_limit);      grpc_chttp2_cancel_stream(          exec_ctx, t, s,          grpc_error_set_int(              GRPC_ERROR_CREATE("received initial metadata size exceeds limit"),              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED));      grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);      s->seen_error = true;      GRPC_MDELEM_UNREF(md);    } else {      grpc_chttp2_incoming_metadata_buffer_add(&s->metadata_buffer[0], md);    }  }  GPR_TIMER_END("on_initial_header", 0);}

static void destroy_call(grpc_exec_ctx *exec_ctx, void *call, int success) {  size_t i;  int ii;  grpc_call *c = call;  GPR_TIMER_BEGIN("destroy_call", 0);  for (i = 0; i < 2; i++) {    grpc_metadata_batch_destroy(        &c->metadata_batch[1 /* is_receiving */][i /* is_initial */]);  }  if (c->receiving_stream != NULL) {    grpc_byte_stream_destroy(c->receiving_stream);  }  grpc_call_stack_destroy(exec_ctx, CALL_STACK_FROM_CALL(c));  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->channel, "call");  gpr_mu_destroy(&c->mu);  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {    if (c->status[i].details) {      GRPC_MDSTR_UNREF(c->status[i].details);    }  }  for (ii = 0; ii < c->send_extra_metadata_count; ii++) {    GRPC_MDELEM_UNREF(c->send_extra_metadata[ii].md);  }  for (i = 0; i < GRPC_CONTEXT_COUNT; i++) {    if (c->context[i].destroy) {      c->context[i].destroy(c->context[i].value);    }  }  if (c->cq) {    GRPC_CQ_INTERNAL_UNREF(c->cq, "bind");  }  gpr_free(c);  GPR_TIMER_END("destroy_call", 0);}

void grpc_call_destroy(grpc_call *c) {  int cancel;  grpc_call *parent = c->parent;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  GPR_TIMER_BEGIN("grpc_call_destroy", 0);  GRPC_API_TRACE("grpc_call_destroy(c=%p)", 1, (c));  if (parent) {    gpr_mu_lock(&parent->mu);    if (c == parent->first_child) {      parent->first_child = c->sibling_next;      if (c == parent->first_child) {        parent->first_child = NULL;      }      c->sibling_prev->sibling_next = c->sibling_next;      c->sibling_next->sibling_prev = c->sibling_prev;    }    gpr_mu_unlock(&parent->mu);    GRPC_CALL_INTERNAL_UNREF(&exec_ctx, parent, "child");  }  gpr_mu_lock(&c->mu);  GPR_ASSERT(!c->destroy_called);  c->destroy_called = 1;  if (c->have_alarm) {    grpc_timer_cancel(&exec_ctx, &c->alarm);  }  cancel = !c->received_final_op;  gpr_mu_unlock(&c->mu);  if (cancel) grpc_call_cancel(c, NULL);  GRPC_CALL_INTERNAL_UNREF(&exec_ctx, c, "destroy");  grpc_exec_ctx_finish(&exec_ctx);  GPR_TIMER_END("grpc_call_destroy", 0);}

void grpc_chttp2_prepare_to_read(    grpc_chttp2_transport_global *transport_global,    grpc_chttp2_transport_parsing *transport_parsing) {  grpc_chttp2_stream_global *stream_global;  grpc_chttp2_stream_parsing *stream_parsing;  GPR_TIMER_BEGIN("grpc_chttp2_prepare_to_read", 0);  transport_parsing->next_stream_id = transport_global->next_stream_id;  memcpy(transport_parsing->last_sent_settings,         transport_global->settings[GRPC_SENT_SETTINGS],         sizeof(transport_parsing->last_sent_settings));  transport_parsing->max_frame_size =      transport_global->settings[GRPC_ACKED_SETTINGS]                                [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE];  /* update the parsing view of incoming window */  while (grpc_chttp2_list_pop_unannounced_incoming_window_available(      transport_global, transport_parsing, &stream_global, &stream_parsing)) {    GRPC_CHTTP2_FLOW_MOVE_STREAM("parse", transport_parsing, stream_parsing,                                 incoming_window, stream_global,                                 unannounced_incoming_window_for_parse);  }  GPR_TIMER_END("grpc_chttp2_prepare_to_read", 0);}

static void tcp_handle_write(grpc_exec_ctx *exec_ctx, void *arg /* grpc_tcp */,                             bool success) {  grpc_tcp *tcp = (grpc_tcp *)arg;  flush_result status;  grpc_closure *cb;  if (!success) {    cb = tcp->write_cb;    tcp->write_cb = NULL;    cb->cb(exec_ctx, cb->cb_arg, 0);    TCP_UNREF(exec_ctx, tcp, "write");    return;  }  status = tcp_flush(tcp);  if (status == FLUSH_PENDING) {    grpc_fd_notify_on_write(exec_ctx, tcp->em_fd, &tcp->write_closure);  } else {    cb = tcp->write_cb;    tcp->write_cb = NULL;    GPR_TIMER_BEGIN("tcp_handle_write.cb", 0);    cb->cb(exec_ctx, cb->cb_arg, status == FLUSH_DONE);    GPR_TIMER_END("tcp_handle_write.cb", 0);    TCP_UNREF(exec_ctx, tcp, "write");  }}

static void lr_start_transport_stream_op_batch(    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,    grpc_transport_stream_op_batch *op) {  GPR_TIMER_BEGIN("lr_start_transport_stream_op_batch", 0);  call_data *calld = (call_data *)elem->call_data;  if (op->recv_initial_metadata) {    /* substitute our callback for the higher callback */    calld->recv_initial_metadata =        op->payload->recv_initial_metadata.recv_initial_metadata;    calld->ops_recv_initial_metadata_ready =        op->payload->recv_initial_metadata.recv_initial_metadata_ready;    op->payload->recv_initial_metadata.recv_initial_metadata_ready =        &calld->on_initial_md_ready;  } else if (op->send_trailing_metadata) {    GRPC_LOG_IF_ERROR(        "grpc_metadata_batch_filter",        grpc_metadata_batch_filter(            exec_ctx,            op->payload->send_trailing_metadata.send_trailing_metadata,            lr_trailing_md_filter, elem,            "LR trailing metadata filtering error"));  }  grpc_call_next_op(exec_ctx, elem, op);  GPR_TIMER_END("lr_start_transport_stream_op_batch", 0);}

static void eventfd_wakeup(grpc_wakeup_fd* fd_info) {  int err;  GPR_TIMER_BEGIN("eventfd_wakeup", 0);  do {    err = eventfd_write(fd_info->read_fd, 1);  } while (err < 0 && errno == EINTR);  GPR_TIMER_END("eventfd_wakeup", 0);}

int gpr_mu_trylock(gpr_mu* mu) {  int err;  GPR_TIMER_BEGIN("gpr_mu_trylock", 0);  err = pthread_mutex_trylock(mu);  GPR_ASSERT(err == 0 || err == EBUSY);  GPR_TIMER_END("gpr_mu_trylock", 0);  return err == 0;}

static void hc_start_transport_op(grpc_exec_ctx *exec_ctx,                                  grpc_call_element *elem,                                  grpc_transport_stream_op *op) {  GPR_TIMER_BEGIN("hc_start_transport_op", 0);  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);  hc_mutate_op(elem, op);  GPR_TIMER_END("hc_start_transport_op", 0);  grpc_call_next_op(exec_ctx, elem, op);}

static void step_ping_pong_stream(void) {  grpc_call_error error;  GPR_TIMER_BEGIN("ping_pong", 1);  error = grpc_call_start_batch(call, stream_step_ops, 2, (void *)1, NULL);  GPR_ASSERT(GRPC_CALL_OK == error);  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);  grpc_byte_buffer_destroy(response_payload_recv);  GPR_TIMER_END("ping_pong", 1);}

static void on_trailing_header(grpc_exec_ctx *exec_ctx, void *tp,                               grpc_mdelem md) {  grpc_chttp2_transport *t = (grpc_chttp2_transport *)tp;  grpc_chttp2_stream *s = t->incoming_stream;  GPR_TIMER_BEGIN("on_trailing_header", 0);  GPR_ASSERT(s != NULL);  if (GRPC_TRACER_ON(grpc_http_trace)) {    char *key = grpc_slice_to_c_string(GRPC_MDKEY(md));    char *value =        grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);    gpr_log(GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", s->id,            t->is_client ? "CLI" : "SVR", key, value);    gpr_free(key);    gpr_free(value);  }  if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&      !grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {    /* TODO(ctiller): check for a status like " 0" */    s->seen_error = true;  }  const size_t new_size = s->metadata_buffer[1].size + GRPC_MDELEM_LENGTH(md);  const size_t metadata_size_limit =      t->settings[GRPC_ACKED_SETTINGS]                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];  if (new_size > metadata_size_limit) {    gpr_log(GPR_DEBUG,            "received trailing metadata size exceeds limit (%" PRIuPTR            " vs. %" PRIuPTR ")",            new_size, metadata_size_limit);    grpc_chttp2_cancel_stream(        exec_ctx, t, s,        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(                               "received trailing metadata size exceeds limit"),                           GRPC_ERROR_INT_GRPC_STATUS,                           GRPC_STATUS_RESOURCE_EXHAUSTED));    grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);    s->seen_error = true;    GRPC_MDELEM_UNREF(exec_ctx, md);  } else {    grpc_error *error = grpc_chttp2_incoming_metadata_buffer_add(        exec_ctx, &s->metadata_buffer[1], md);    if (error != GRPC_ERROR_NONE) {      grpc_chttp2_cancel_stream(exec_ctx, t, s, error);      grpc_chttp2_parsing_become_skip_parser(exec_ctx, t);      s->seen_error = true;      GRPC_MDELEM_UNREF(exec_ctx, md);    }  }  GPR_TIMER_END("on_trailing_header", 0);}

static void execute_op(grpc_exec_ctx *exec_ctx, grpc_call *call,                       grpc_transport_stream_op *op) {  grpc_call_element *elem;  GPR_TIMER_BEGIN("execute_op", 0);  elem = CALL_ELEM_FROM_CALL(call, 0);  op->context = call->context;  elem->filter->start_transport_stream_op(exec_ctx, elem, op);  GPR_TIMER_END("execute_op", 0);}

int grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx) {  int did_something = 0;  GPR_TIMER_BEGIN("grpc_exec_ctx_flush", 0);  while (!grpc_closure_list_empty(exec_ctx->closure_list)) {    grpc_closure *c = exec_ctx->closure_list.head;    exec_ctx->closure_list.head = exec_ctx->closure_list.tail = NULL;    while (c != NULL) {      int success = (int)(c->final_data & 1);      grpc_closure *next = (grpc_closure *)(c->final_data & ~(uintptr_t)1);      did_something++;      GPR_TIMER_BEGIN("grpc_exec_ctx_flush.cb", 0);      c->cb(exec_ctx, c->cb_arg, success);      GPR_TIMER_END("grpc_exec_ctx_flush.cb", 0);      c = next;    }  }  GPR_TIMER_END("grpc_exec_ctx_flush", 0);  return did_something;}

static void add_waiting_locked(call_data *calld, grpc_transport_stream_op *op) {  GPR_TIMER_BEGIN("add_waiting_locked", 0);  if (calld->waiting_ops_count == calld->waiting_ops_capacity) {    calld->waiting_ops_capacity = GPR_MAX(3, 2 * calld->waiting_ops_capacity);    calld->waiting_ops =        gpr_realloc(calld->waiting_ops,                    calld->waiting_ops_capacity * sizeof(*calld->waiting_ops));  }  calld->waiting_ops[calld->waiting_ops_count++] = op;  GPR_TIMER_END("add_waiting_locked", 0);}

static void add_waiting_locked(grpc_subchannel_call_holder *holder,                               grpc_transport_stream_op *op) {  GPR_TIMER_BEGIN("add_waiting_locked", 0);  if (holder->waiting_ops_count == holder->waiting_ops_capacity) {    holder->waiting_ops_capacity = GPR_MAX(3, 2 * holder->waiting_ops_capacity);    holder->waiting_ops =        gpr_realloc(holder->waiting_ops, holder->waiting_ops_capacity *                                             sizeof(*holder->waiting_ops));  }  holder->waiting_ops[holder->waiting_ops_count++] = *op;  GPR_TIMER_END("add_waiting_locked", 0);}

static void server_on_done_recv(grpc_exec_ctx *exec_ctx, void *ptr,                                grpc_error *error) {  GPR_TIMER_BEGIN("census-server:server_on_done_recv", 0);  grpc_call_element *elem = ptr;  call_data *calld = elem->call_data;  channel_data *chand = elem->channel_data;  if (error == GRPC_ERROR_NONE) {    extract_and_annotate_method_tag(calld->recv_initial_metadata, calld, chand);  }  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, error);  GPR_TIMER_END("census-server:server_on_done_recv", 0);}

static grpc_mdelem *recv_initial_filter(void *callp, grpc_mdelem *elem) {  grpc_call *call = callp;  elem = recv_common_filter(call, elem);  if (elem == NULL) {    return NULL;  } else if (elem->key ==             grpc_channel_get_compression_algorithm_string(call->channel)) {    GPR_TIMER_BEGIN("compression_algorithm", 0);    set_compression_algorithm(call, decode_compression(elem));    GPR_TIMER_END("compression_algorithm", 0);    return NULL;  } else if (elem->key == grpc_channel_get_encodings_accepted_by_peer_string(                              call->channel)) {    GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);    set_encodings_accepted_by_peer(call, elem);    GPR_TIMER_END("encodings_accepted_by_peer", 0);    return NULL;  } else {    return publish_app_metadata(call, elem, 0);  }}

void grpc_workqueue_enqueue(grpc_exec_ctx *exec_ctx, grpc_workqueue *workqueue,                            grpc_closure *closure, grpc_error *error) {  GPR_TIMER_BEGIN("workqueue.enqueue", 0);  gpr_atm last = gpr_atm_full_fetch_add(&workqueue->state, 2);  GPR_ASSERT(last & 1);  closure->error = error;  gpr_mpscq_push(&workqueue->queue, &closure->next_data.atm_next);  if (last == 1) {    wakeup(exec_ctx, workqueue);  }  GPR_TIMER_END("workqueue.enqueue", 0);}

static void tcp_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,                      gpr_slice_buffer *buf, grpc_closure *cb) {  grpc_tcp *tcp = (grpc_tcp *)ep;  flush_result status;  if (grpc_tcp_trace) {    size_t i;    for (i = 0; i < buf->count; i++) {      char *data =          gpr_dump_slice(buf->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);      gpr_log(GPR_DEBUG, "WRITE %p: %s", tcp, data);      gpr_free(data);    }  }  GPR_TIMER_BEGIN("tcp_write", 0);  GPR_ASSERT(tcp->write_cb == NULL);  if (buf->length == 0) {    GPR_TIMER_END("tcp_write", 0);    grpc_exec_ctx_enqueue(exec_ctx, cb, true, NULL);    return;  }  tcp->outgoing_buffer = buf;  tcp->outgoing_slice_idx = 0;  tcp->outgoing_byte_idx = 0;  status = tcp_flush(tcp);  if (status == FLUSH_PENDING) {    TCP_REF(tcp, "write");    tcp->write_cb = cb;    grpc_fd_notify_on_write(exec_ctx, tcp->em_fd, &tcp->write_closure);  } else {    grpc_exec_ctx_enqueue(exec_ctx, cb, status == FLUSH_DONE, NULL);  }  GPR_TIMER_END("tcp_write", 0);}

static void on_readable(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {  GPR_TIMER_BEGIN("workqueue.on_readable", 0);  grpc_workqueue *workqueue = arg;  if (error != GRPC_ERROR_NONE) {    /* HACK: let wakeup_fd code know that we stole the fd */    workqueue->wakeup_fd.read_fd = 0;    grpc_wakeup_fd_destroy(&workqueue->wakeup_fd);    grpc_fd_orphan(exec_ctx, workqueue->wakeup_read_fd, NULL, NULL, "destroy");    GPR_ASSERT(gpr_atm_no_barrier_load(&workqueue->state) == 0);    gpr_free(workqueue);  } else {    error = grpc_wakeup_fd_consume_wakeup(&workqueue->wakeup_fd);    gpr_mpscq_node *n = gpr_mpscq_pop(&workqueue->queue);    if (error == GRPC_ERROR_NONE) {      grpc_fd_notify_on_read(exec_ctx, workqueue->wakeup_read_fd,                             &workqueue->read_closure);    } else {      /* recurse to get error handling */      on_readable(exec_ctx, arg, error);    }    if (n == NULL) {      /* try again - queue in an inconsistant state */      wakeup(exec_ctx, workqueue);    } else {      switch (gpr_atm_full_fetch_add(&workqueue->state, -2)) {        case 3:  // had one count, one unorphaned --> done, unorphaned          break;        case 2:  // had one count, one orphaned --> done, orphaned          workqueue_destroy(exec_ctx, workqueue);          break;        case 1:        case 0:          // these values are illegal - representing an already done or          // deleted workqueue          GPR_UNREACHABLE_CODE(break);        default:          // schedule a wakeup since there's more to do          wakeup(exec_ctx, workqueue);      }      grpc_closure *cl = (grpc_closure *)n;      grpc_error *clerr = cl->error;      cl->cb(exec_ctx, cl->cb_arg, clerr);      GRPC_ERROR_UNREF(clerr);    }  }  GPR_TIMER_END("workqueue.on_readable", 0);}

static void step_ping_pong_request(void) {  GPR_TIMER_BEGIN("ping_pong", 1);  call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,                                  "/Reflector/reflectUnary", "localhost",                                  gpr_inf_future(GPR_CLOCK_REALTIME), NULL);  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,                                                   (size_t)(op - ops),                                                   (void *)1, NULL));  grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);  grpc_call_destroy(call);  grpc_byte_buffer_destroy(response_payload_recv);  call = NULL;  GPR_TIMER_END("ping_pong", 1);}

static void call_ready(grpc_exec_ctx *exec_ctx, void *arg, int success) {  grpc_subchannel_call_holder *holder = arg;  GPR_TIMER_BEGIN("call_ready", 0);  gpr_mu_lock(&holder->mu);  GPR_ASSERT(holder->creation_phase ==             GRPC_SUBCHANNEL_CALL_HOLDER_CREATING_CALL);  holder->creation_phase = GRPC_SUBCHANNEL_CALL_HOLDER_NOT_CREATING;  if (GET_CALL(holder) != NULL) {    retry_waiting_locked(exec_ctx, holder);  } else {    fail_locked(exec_ctx, holder);  }  gpr_mu_unlock(&holder->mu);  GPR_TIMER_END("call_ready", 0);}

static void on_initial_header(void *tp, grpc_mdelem *md) {  grpc_chttp2_transport_parsing *transport_parsing = tp;  grpc_chttp2_stream_parsing *stream_parsing =      transport_parsing->incoming_stream;  GPR_TIMER_BEGIN("on_initial_header", 0);  GPR_ASSERT(stream_parsing);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", stream_parsing->id,      transport_parsing->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    stream_parsing->seen_error = 1;  }  if (md->key == GRPC_MDSTR_GRPC_TIMEOUT) {    gpr_timespec *cached_timeout = grpc_mdelem_get_user_data(md, free_timeout);    if (!cached_timeout) {      /* not already parsed: parse it now, and store the result away */      cached_timeout = gpr_malloc(sizeof(gpr_timespec));      if (!grpc_chttp2_decode_timeout(grpc_mdstr_as_c_string(md->value),                                      cached_timeout)) {        gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'",                grpc_mdstr_as_c_string(md->value));        *cached_timeout = gpr_inf_future(GPR_TIMESPAN);      }      grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);    }    grpc_chttp2_incoming_metadata_buffer_set_deadline(        &stream_parsing->metadata_buffer[0],        gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), *cached_timeout));    GRPC_MDELEM_UNREF(md);  } else {    grpc_chttp2_incoming_metadata_buffer_add(        &stream_parsing->metadata_buffer[0], md);  }  grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing);  GPR_TIMER_END("on_initial_header", 0);}

grpc_completion_queue *grpc_completion_queue_create(void *reserved) {  grpc_completion_queue *cc;  GPR_ASSERT(!reserved);  GPR_TIMER_BEGIN("grpc_completion_queue_create", 0);  GRPC_API_TRACE("grpc_completion_queue_create(reserved=%p)", 1, (reserved));  gpr_mu_lock(&g_freelist_mu);  if (g_freelist == NULL) {    gpr_mu_unlock(&g_freelist_mu);    cc = gpr_malloc(sizeof(grpc_completion_queue) + grpc_pollset_size());    grpc_pollset_init(POLLSET_FROM_CQ(cc), &cc->mu);#ifndef NDEBUG    cc->outstanding_tags = NULL;    cc->outstanding_tag_capacity = 0;#endif  } else {    cc = g_freelist;    g_freelist = g_freelist->next_free;    gpr_mu_unlock(&g_freelist_mu);    /* pollset already initialized */  }  /* Initial ref is dropped by grpc_completion_queue_shutdown */  gpr_ref_init(&cc->pending_events, 1);  /* One for destroy(), one for pollset_shutdown */  gpr_ref_init(&cc->owning_refs, 2);  cc->completed_tail = &cc->completed_head;  cc->completed_head.next = (uintptr_t)cc->completed_tail;  cc->shutdown = 0;  cc->shutdown_called = 0;  cc->is_server_cq = 0;  cc->is_non_listening_server_cq = 0;  cc->num_pluckers = 0;#ifndef NDEBUG  cc->outstanding_tag_count = 0;#endif  grpc_closure_init(&cc->pollset_shutdown_done, on_pollset_shutdown_done, cc);  GPR_TIMER_END("grpc_completion_queue_create", 0);  return cc;}

static void on_trailing_header(void *tp, grpc_mdelem *md) {  grpc_chttp2_transport_parsing *transport_parsing = tp;  grpc_chttp2_stream_parsing *stream_parsing =      transport_parsing->incoming_stream;  GPR_TIMER_BEGIN("on_trailing_header", 0);  GPR_ASSERT(stream_parsing);  GRPC_CHTTP2_IF_TRACING(gpr_log(      GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", stream_parsing->id,      transport_parsing->is_client ? "CLI" : "SVR",      grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value)));  if (md->key == GRPC_MDSTR_GRPC_STATUS && md != GRPC_MDELEM_GRPC_STATUS_0) {    /* TODO(ctiller): check for a status like " 0" */    stream_parsing->seen_error = true;  }  const size_t new_size =      stream_parsing->metadata_buffer[1].size + GRPC_MDELEM_LENGTH(md);  grpc_chttp2_transport_global *transport_global =      &TRANSPORT_FROM_PARSING(transport_parsing)->global;  const size_t metadata_size_limit =      transport_global->settings[GRPC_LOCAL_SETTINGS]                                [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];  if (new_size > metadata_size_limit) {    if (!stream_parsing->exceeded_metadata_size) {      gpr_log(GPR_DEBUG,              "received trailing metadata size exceeds limit (%" PRIuPTR              " vs. %" PRIuPTR ")",              new_size, metadata_size_limit);      stream_parsing->seen_error = true;      stream_parsing->exceeded_metadata_size = true;    }    GRPC_MDELEM_UNREF(md);  } else {    grpc_chttp2_incoming_metadata_buffer_add(        &stream_parsing->metadata_buffer[1], md);  }  grpc_chttp2_list_add_parsing_seen_stream(transport_parsing, stream_parsing);  GPR_TIMER_END("on_trailing_header", 0);}