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

int grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl *tbl,                                             uint32_t bytes) {  if (tbl->current_table_bytes == bytes) {    return 1;  }  if (bytes > tbl->max_bytes) {    if (grpc_http_trace) {      gpr_log(GPR_ERROR,              "Attempt to make hpack table %d bytes when max is %d bytes",              bytes, tbl->max_bytes);    }    return 0;  }  if (grpc_http_trace) {    gpr_log(GPR_DEBUG, "Update hpack parser table size to %d", bytes);  }  while (tbl->mem_used > bytes) {    evict1(tbl);  }  tbl->current_table_bytes = bytes;  tbl->max_entries = entries_for_bytes(bytes);  if (tbl->max_entries > tbl->cap_entries) {    rebuild_ents(tbl, GPR_MAX(tbl->max_entries, 2 * tbl->cap_entries));  } else if (tbl->max_entries < tbl->cap_entries / 3) {    uint32_t new_cap = GPR_MAX(tbl->max_entries, 16u);    if (new_cap != tbl->cap_entries) {      rebuild_ents(tbl, new_cap);    }  }  return 1;}

int main(int argc, char **argv) {    int four[4];    int five[5];    uint32_t bitset = 0;    grpc_test_init(argc, argv);    GPR_ASSERT(GPR_MIN(1, 2) == 1);    GPR_ASSERT(GPR_MAX(1, 2) == 2);    GPR_ASSERT(GPR_MIN(2, 1) == 1);    GPR_ASSERT(GPR_MAX(2, 1) == 2);    GPR_ASSERT(GPR_CLAMP(1, 0, 2) == 1);    GPR_ASSERT(GPR_CLAMP(0, 0, 2) == 0);    GPR_ASSERT(GPR_CLAMP(2, 0, 2) == 2);    GPR_ASSERT(GPR_CLAMP(-1, 0, 2) == 0);    GPR_ASSERT(GPR_CLAMP(3, 0, 2) == 2);    GPR_ASSERT(GPR_ROTL((uint32_t)0x80000001, 1) == 3);    GPR_ASSERT(GPR_ROTR((uint32_t)0x80000001, 1) == 0xc0000000);    GPR_ASSERT(GPR_ARRAY_SIZE(four) == 4);    GPR_ASSERT(GPR_ARRAY_SIZE(five) == 5);    GPR_ASSERT(GPR_BITCOUNT((1u << 31) - 1) == 31);    GPR_ASSERT(GPR_BITCOUNT(1u << 3) == 1);    GPR_ASSERT(GPR_BITCOUNT(0) == 0);    GPR_ASSERT(GPR_BITSET(&bitset, 3) == 8);    GPR_ASSERT(GPR_BITCOUNT(bitset) == 1);    GPR_ASSERT(GPR_BITGET(bitset, 3) == 1);    GPR_ASSERT(GPR_BITSET(&bitset, 1) == 10);    GPR_ASSERT(GPR_BITCOUNT(bitset) == 2);    GPR_ASSERT(GPR_BITCLEAR(&bitset, 3) == 2);    GPR_ASSERT(GPR_BITCOUNT(bitset) == 1);    GPR_ASSERT(GPR_BITGET(bitset, 3) == 0);    return 0;}

static void recv_metadata(grpc_call *call, grpc_metadata_batch *md) {  grpc_linked_mdelem *l;  grpc_metadata_array *dest;  grpc_metadata *mdusr;  int is_trailing;  grpc_mdctx *mdctx = call->metadata_context;  is_trailing = call->read_state >= READ_STATE_GOT_INITIAL_METADATA;  for (l = md->list.head; l != NULL; l = l->next) {    grpc_mdelem *md = l->md;    grpc_mdstr *key = md->key;    if (key == grpc_channel_get_status_string(call->channel)) {      set_status_code(call, STATUS_FROM_WIRE, decode_status(md));    } else if (key == grpc_channel_get_message_string(call->channel)) {      set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));    } else {      dest = &call->buffered_metadata[is_trailing];      if (dest->count == dest->capacity) {        dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);        dest->metadata =            gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);      }      mdusr = &dest->metadata[dest->count++];      mdusr->key = grpc_mdstr_as_c_string(md->key);      mdusr->value = grpc_mdstr_as_c_string(md->value);      mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);      if (call->owned_metadata_count == call->owned_metadata_capacity) {        call->owned_metadata_capacity =            GPR_MAX(call->owned_metadata_capacity + 8,                    call->owned_metadata_capacity * 2);        call->owned_metadata =            gpr_realloc(call->owned_metadata,                        sizeof(grpc_mdelem *) * call->owned_metadata_capacity);      }      call->owned_metadata[call->owned_metadata_count++] = md;      l->md = 0;    }  }  if (gpr_time_cmp(md->deadline, gpr_inf_future) != 0) {    set_deadline_alarm(call, md->deadline);  }  if (!is_trailing) {    call->read_state = READ_STATE_GOT_INITIAL_METADATA;  }  grpc_mdctx_lock(mdctx);  for (l = md->list.head; l; l = l->next) {    if (l->md) grpc_mdctx_locked_mdelem_unref(mdctx, l->md);  }  for (l = md->garbage.head; l; l = l->next) {    grpc_mdctx_locked_mdelem_unref(mdctx, l->md);  }  grpc_mdctx_unlock(mdctx);}

grpc_call_error grpc_call_add_metadata_old(grpc_call *call,                                           grpc_metadata *metadata,                                           gpr_uint32 flags) {  legacy_state *ls;  grpc_metadata *mdout;  lock(call);  ls = get_legacy_state(call);  if (ls->md_out_count[ls->md_out_buffer] ==      ls->md_out_capacity[ls->md_out_buffer]) {    ls->md_out_capacity[ls->md_out_buffer] =        GPR_MAX(ls->md_out_capacity[ls->md_out_buffer] * 3 / 2,                ls->md_out_capacity[ls->md_out_buffer] + 8);    ls->md_out[ls->md_out_buffer] = gpr_realloc(        ls->md_out[ls->md_out_buffer],        sizeof(grpc_metadata) * ls->md_out_capacity[ls->md_out_buffer]);  }  mdout = &ls->md_out[ls->md_out_buffer][ls->md_out_count[ls->md_out_buffer]++];  mdout->key = gpr_strdup(metadata->key);  mdout->value = gpr_malloc(metadata->value_length);  mdout->value_length = metadata->value_length;  memcpy((char *)mdout->value, metadata->value, metadata->value_length);  unlock(call);  return GRPC_CALL_OK;}

void grpc_cq_internal_unref(grpc_completion_queue *cc, const char *reason,                            const char *file, int line) {  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "CQ:%p unref %d -> %d %s", cc,          (int)cc->owning_refs.count, (int)cc->owning_refs.count - 1, reason);#elsevoid grpc_cq_internal_unref(grpc_completion_queue *cc) {#endif  if (gpr_unref(&cc->owning_refs)) {    GPR_ASSERT(cc->completed_head.next == (uintptr_t)&cc->completed_head);    grpc_pollset_destroy(POLLSET_FROM_CQ(cc));#ifndef NDEBUG    gpr_free(cc->outstanding_tags);#endif    gpr_free(cc);  }}void grpc_cq_begin_op(grpc_completion_queue *cc, void *tag) {#ifndef NDEBUG  gpr_mu_lock(cc->mu);  GPR_ASSERT(!cc->shutdown_called);  if (cc->outstanding_tag_count == cc->outstanding_tag_capacity) {    cc->outstanding_tag_capacity = GPR_MAX(4, 2 * cc->outstanding_tag_capacity);    cc->outstanding_tags =        gpr_realloc(cc->outstanding_tags, sizeof(*cc->outstanding_tags) *                                              cc->outstanding_tag_capacity);  }  cc->outstanding_tags[cc->outstanding_tag_count++] = tag;  gpr_mu_unlock(cc->mu);#endif  gpr_ref(&cc->pending_events);}

static void get_final_details(grpc_call *call, grpc_ioreq_data out) {  int i;  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {    if (call->status[i].is_set) {      if (call->status[i].details) {        gpr_slice details = call->status[i].details->slice;        size_t len = GPR_SLICE_LENGTH(details);        if (len + 1 > *out.recv_status_details.details_capacity) {          *out.recv_status_details.details_capacity = GPR_MAX(              len + 1, *out.recv_status_details.details_capacity * 3 / 2);          *out.recv_status_details.details =              gpr_realloc(*out.recv_status_details.details,                          *out.recv_status_details.details_capacity);        }        memcpy(*out.recv_status_details.details, GPR_SLICE_START_PTR(details),               len);        (*out.recv_status_details.details)[len] = 0;      } else {        goto no_details;      }      return;    }  }no_details:  if (0 == *out.recv_status_details.details_capacity) {    *out.recv_status_details.details_capacity = 8;    *out.recv_status_details.details =        gpr_malloc(*out.recv_status_details.details_capacity);  }  **out.recv_status_details.details = 0;}

void grpc_incoming_metadata_buffer_move_to_referencing_sopb(    grpc_chttp2_incoming_metadata_buffer *src,    grpc_chttp2_incoming_metadata_buffer *dst, grpc_stream_op_buffer *sopb) {  size_t delta;  size_t i;  dst->deadline = gpr_time_min(src->deadline, dst->deadline);  if (src->count == 0) {    return;  }  if (dst->count == 0) {    grpc_chttp2_incoming_metadata_buffer_swap(src, dst);    return;  }  delta = dst->count;  if (dst->capacity < src->count + dst->count) {    dst->capacity = GPR_MAX(dst->capacity * 2, src->count + dst->count);    dst->elems = gpr_realloc(dst->elems, dst->capacity * sizeof(*dst->elems));  }  memcpy(dst->elems + dst->count, src->elems, src->count * sizeof(*src->elems));  dst->count += src->count;  for (i = 0; i < sopb->nops; i++) {    if (sopb->ops[i].type != GRPC_OP_METADATA) continue;    sopb->ops[i].data.metadata.list.tail =        (void *)(delta + (gpr_intptr)sopb->ops[i].data.metadata.list.tail);  }  src->count = 0;}

static void add_sopb_headers(int n, ...) {  int i;  grpc_metadata_batch b;  va_list l;  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * n);  grpc_metadata_batch_init(&b);  va_start(l, n);  for (i = 0; i < n; i++) {    char *key = va_arg(l, char *);    char *value = va_arg(l, char *);    if (i) {      e[i - 1].next = &e[i];      e[i].prev = &e[i - 1];    }    e[i].md = grpc_mdelem_from_strings(g_mdctx, key, value);  }  e[0].prev = NULL;  e[n - 1].next = NULL;  va_end(l);  b.list.head = &e[0];  b.list.tail = &e[n - 1];  if (cap_to_delete == num_to_delete) {    cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000);    to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete);  }  to_delete[num_to_delete++] = e;  grpc_sopb_add_metadata(&g_sopb, b);}

void grpc_chttp2_stream_map_move_into(grpc_chttp2_stream_map *src,                                      grpc_chttp2_stream_map *dst) {  /* if src is empty we dont need to do anything */  if (src->count == src->free) {    return;  }  /* if dst is empty we simply need to swap */  if (dst->count == dst->free) {    GPR_SWAP(grpc_chttp2_stream_map, *src, *dst);    return;  }  /* the first element of src must be greater than the last of dst...   * however the maps may need compacting for this property to hold */  if (src->keys[0] <= dst->keys[dst->count - 1]) {    src->count = compact(src->keys, src->values, src->count);    src->free = 0;    dst->count = compact(dst->keys, dst->values, dst->count);    dst->free = 0;  }  GPR_ASSERT(src->keys[0] > dst->keys[dst->count - 1]);  /* if dst doesn't have capacity, resize */  if (dst->count + src->count > dst->capacity) {    dst->capacity = GPR_MAX(dst->capacity * 3 / 2, dst->count + src->count);    dst->keys = gpr_realloc(dst->keys, dst->capacity * sizeof(uint32_t));    dst->values = gpr_realloc(dst->values, dst->capacity * sizeof(void *));  }  memcpy(dst->keys + dst->count, src->keys, src->count * sizeof(uint32_t));  memcpy(dst->values + dst->count, src->values, src->count * sizeof(void *));  dst->count += src->count;  dst->free += src->free;  src->count = 0;  src->free = 0;}

/* verify that the output generated by encoding the stream matches the   hexstring passed in */static void verify(size_t window_available, int eof, size_t expect_window_used,                   const char *expected, size_t nheaders, ...) {  grpc_slice_buffer output;  grpc_slice merged;  grpc_slice expect = parse_hexstring(expected);  size_t i;  va_list l;  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * nheaders);  grpc_metadata_batch b;  grpc_metadata_batch_init(&b);  va_start(l, nheaders);  for (i = 0; i < nheaders; i++) {    char *key = va_arg(l, char *);    char *value = va_arg(l, char *);    if (i) {      e[i - 1].next = &e[i];      e[i].prev = &e[i - 1];    }    e[i].md = grpc_mdelem_from_strings(key, value);  }  e[0].prev = NULL;  e[nheaders - 1].next = NULL;  va_end(l);  b.list.head = &e[0];  b.list.tail = &e[nheaders - 1];  if (cap_to_delete == num_to_delete) {    cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000);    to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete);  }  to_delete[num_to_delete++] = e;  grpc_slice_buffer_init(&output);  grpc_transport_one_way_stats stats;  memset(&stats, 0, sizeof(stats));  grpc_chttp2_encode_header(&g_compressor, 0xdeadbeef, &b, eof, 16384, &stats,                            &output);  merged = grpc_slice_merge(output.slices, output.count);  grpc_slice_buffer_destroy(&output);  grpc_metadata_batch_destroy(&b);  if (0 != grpc_slice_cmp(merged, expect)) {    char *expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);    char *got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);    gpr_log(GPR_ERROR, "mismatched output for %s", expected);    gpr_log(GPR_ERROR, "EXPECT: %s", expect_str);    gpr_log(GPR_ERROR, "GOT:    %s", got_str);    gpr_free(expect_str);    gpr_free(got_str);    g_failure = 1;  }  grpc_slice_unref(merged);  grpc_slice_unref(expect);}

static void pg_merge(grpc_exec_ctx *exec_ctx, polling_group *a,                     polling_group *b) {  for (;;) {    if (a == b) {      pg_unref(a);      pg_unref(b);      return;    }    if (a > b) GPR_SWAP(polling_group *, a, b);    gpr_mu_lock(&a->po.mu);    gpr_mu_lock(&b->po.mu);    if (a->po.group != NULL) {      polling_group *m2 = pg_ref(a->po.group);      gpr_mu_unlock(&a->po.mu);      gpr_mu_unlock(&b->po.mu);      pg_unref(a);      a = m2;    } else if (b->po.group != NULL) {      polling_group *m2 = pg_ref(b->po.group);      gpr_mu_unlock(&a->po.mu);      gpr_mu_unlock(&b->po.mu);      pg_unref(b);      b = m2;    } else {      break;    }  }  polling_group **unref = NULL;  size_t unref_count = 0;  size_t unref_cap = 0;  b->po.group = a;  pg_broadcast(exec_ctx, a, b);  pg_broadcast(exec_ctx, b, a);  while (b->po.next != &b->po) {    polling_obj *po = b->po.next;    gpr_mu_lock(&po->mu);    if (unref_count == unref_cap) {      unref_cap = GPR_MAX(8, 3 * unref_cap / 2);      unref = gpr_realloc(unref, unref_cap * sizeof(*unref));    }    unref[unref_count++] = po->group;    po->group = pg_ref(a);    // unlink from b    po->prev->next = po->next;    po->next->prev = po->prev;    // link to a    po->next = &a->po;    po->prev = a->po.prev;    po->next->prev = po->prev->next = po;    gpr_mu_unlock(&po->mu);  }  gpr_mu_unlock(&a->po.mu);  gpr_mu_unlock(&b->po.mu);  for (size_t i = 0; i < unref_count; i++) {    pg_unref(unref[i]);  }  gpr_free(unref);  pg_unref(b);}

static void addbuf(const void *data, size_t len) {  if (g_count + len > g_cap) {    g_cap = GPR_MAX(g_count + len, g_cap * 2);    g_buffer = gpr_realloc(g_buffer, g_cap);  }  memcpy(g_buffer + g_count, data, len);  g_count += len;}

static void add_to_free(call_state *call, void *p) {  if (call->num_to_free == call->cap_to_free) {    call->cap_to_free = GPR_MAX(8, 2 * call->cap_to_free);    call->to_free =        gpr_realloc(call->to_free, sizeof(*call->to_free) * call->cap_to_free);  }  call->to_free[call->num_to_free++] = p;}

static int add_header(grpc_http_parser *parser) {  uint8_t *beg = parser->cur_line;  uint8_t *cur = beg;  uint8_t *end = beg + parser->cur_line_length;  size_t *hdr_count = NULL;  grpc_http_header **hdrs = NULL;  grpc_http_header hdr = {NULL, NULL};  GPR_ASSERT(cur != end);  if (*cur == ' ' || *cur == '/t') {    if (grpc_http1_trace)      gpr_log(GPR_ERROR, "Continued header lines not supported yet");    goto error;  }  while (cur != end && *cur != ':') {    cur++;  }  if (cur == end) {    if (grpc_http1_trace) {      gpr_log(GPR_ERROR, "Didn't find ':' in header string");    }    goto error;  }  GPR_ASSERT(cur >= beg);  hdr.key = buf2str(beg, (size_t)(cur - beg));  cur++; /* skip : */  while (cur != end && (*cur == ' ' || *cur == '/t')) {    cur++;  }  GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length);  hdr.value = buf2str(cur, (size_t)(end - cur) - parser->cur_line_end_length);  if (parser->type == GRPC_HTTP_RESPONSE) {    hdr_count = &parser->http.response.hdr_count;    hdrs = &parser->http.response.hdrs;  } else if (parser->type == GRPC_HTTP_REQUEST) {    hdr_count = &parser->http.request.hdr_count;    hdrs = &parser->http.request.hdrs;  } else {    return 0;  }  if (*hdr_count == parser->hdr_capacity) {    parser->hdr_capacity =        GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);    *hdrs = gpr_realloc(*hdrs, parser->hdr_capacity * sizeof(**hdrs));  }  (*hdrs)[(*hdr_count)++] = hdr;  return 1;error:  gpr_free(hdr.key);  gpr_free(hdr.value);  return 0;}

void grpc_chttp2_incoming_metadata_buffer_add(    grpc_chttp2_incoming_metadata_buffer *buffer, grpc_mdelem *elem) {  if (buffer->capacity == buffer->count) {    buffer->capacity = GPR_MAX(8, 2 * buffer->capacity);    buffer->elems =        gpr_realloc(buffer->elems, sizeof(*buffer->elems) * buffer->capacity);  }  buffer->elems[buffer->count++].md = elem;}

static void ensure_auth_context_capacity(grpc_auth_context *ctx) {  if (ctx->properties.count == ctx->properties.capacity) {    ctx->properties.capacity =        GPR_MAX(ctx->properties.capacity + 8, ctx->properties.capacity * 2);    ctx->properties.array =        gpr_realloc(ctx->properties.array,                    ctx->properties.capacity * sizeof(grpc_auth_property));  }}

/* Constructor for channel_data */static void init_channel_elem(grpc_channel_element *elem,                              const grpc_channel_args *args, grpc_mdctx *mdctx,                              int is_first, int is_last) {  size_t i;  size_t gettable_capacity = 0;  /* grab pointers to our data from the channel element */  channel_data *channeld = elem->channel_data;  /* The first and the last filters tend to be implemented differently to     handle the case that there's no 'next' filter to call on the up or down     path */  GPR_ASSERT(!is_first);  GPR_ASSERT(!is_last);  /* initialize members */  channeld->te_trailers = grpc_mdelem_from_strings(mdctx, "te", "trailers");  channeld->status_ok = grpc_mdelem_from_strings(mdctx, ":status", "200");  channeld->status_not_found =      grpc_mdelem_from_strings(mdctx, ":status", "404");  channeld->method_post = grpc_mdelem_from_strings(mdctx, ":method", "POST");  channeld->http_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "http");  channeld->https_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "https");  channeld->grpc_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "grpc");  channeld->path_key = grpc_mdstr_from_string(mdctx, ":path");  channeld->authority_key = grpc_mdstr_from_string(mdctx, ":authority");  channeld->host_key = grpc_mdstr_from_string(mdctx, "host");  channeld->content_type =      grpc_mdelem_from_strings(mdctx, "content-type", "application/grpc");  channeld->mdctx = mdctx;  /* initialize http download support */  channeld->gettable_count = 0;  channeld->gettables = NULL;  for (i = 0; i < args->num_args; i++) {    if (0 == strcmp(args->args[i].key, GRPC_ARG_SERVE_OVER_HTTP)) {      gettable *g;      gpr_slice slice;      grpc_http_server_page *p = args->args[i].value.pointer.p;      if (channeld->gettable_count == gettable_capacity) {        gettable_capacity =            GPR_MAX(gettable_capacity * 3 / 2, gettable_capacity + 1);        channeld->gettables = gpr_realloc(channeld->gettables,                                          gettable_capacity * sizeof(gettable));      }      g = &channeld->gettables[channeld->gettable_count++];      g->path = grpc_mdelem_from_strings(mdctx, ":path", p->path);      g->content_type =          grpc_mdelem_from_strings(mdctx, "content-type", p->content_type);      slice = gpr_slice_from_copied_string(p->content);      g->content = grpc_byte_buffer_create(&slice, 1);      gpr_slice_unref(slice);    }  }}

static void cpstr(char **dest, size_t *capacity, grpc_mdstr *value) {  gpr_slice slice = value->slice;  size_t len = GPR_SLICE_LENGTH(slice);  if (len + 1 > *capacity) {    *capacity = GPR_MAX(len + 1, *capacity * 2);    *dest = gpr_realloc(*dest, *capacity);  }  memcpy(*dest, grpc_mdstr_as_c_string(value), len + 1);}

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 requested_call *requested_call_array_add(requested_call_array *array) {  requested_call *rc;  if (array->count == array->capacity) {    array->capacity = GPR_MAX(array->capacity + 8, array->capacity * 2);    array->calls =        gpr_realloc(array->calls, sizeof(requested_call) * array->capacity);  }  rc = &array->calls[array->count++];  memset(rc, 0, sizeof(*rc));  return rc;}

void grpc_chttp2_incoming_metadata_buffer_add(    grpc_chttp2_incoming_metadata_buffer *buffer, grpc_mdelem *elem) {  GPR_ASSERT(!buffer->published);  if (buffer->capacity == buffer->count) {    buffer->capacity = GPR_MAX(8, 2 * buffer->capacity);    buffer->elems =        gpr_realloc(buffer->elems, sizeof(*buffer->elems) * buffer->capacity);  }  buffer->elems[buffer->count++].md = elem;  buffer->size += GRPC_MDELEM_LENGTH(elem);}

static void multipoll_with_poll_pollset_del_fd(grpc_pollset *pollset,                                               grpc_fd *fd) {  /* will get removed next poll cycle */  pollset_hdr *h = pollset->data.ptr;  if (h->del_count == h->del_capacity) {    h->del_capacity = GPR_MAX(h->del_capacity + 8, h->del_count * 3 / 2);    h->dels = gpr_realloc(h->dels, sizeof(grpc_fd *) * h->del_capacity);  }  h->dels[h->del_count++] = fd;  GRPC_FD_REF(fd, "multipoller_del");}

gpr_avl_node *new_node(void *key, void *value, gpr_avl_node *left,                       gpr_avl_node *right) {  gpr_avl_node *node = gpr_malloc(sizeof(*node));  gpr_ref_init(&node->refs, 1);  node->key = key;  node->value = value;  node->left = assert_invariants(left);  node->right = assert_invariants(right);  node->height = 1 + GPR_MAX(node_height(left), node_height(right));  return node;}

void grpc_endpoint_tests(grpc_endpoint_test_config config,                         grpc_pollset *pollset) {  size_t i;  g_pollset = pollset;  read_and_write_test(config, 10000000, 100000, 8192, 0);  read_and_write_test(config, 1000000, 100000, 1, 0);  read_and_write_test(config, 100000000, 100000, 1, 1);  for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {    read_and_write_test(config, 40320, i, i, 0);  }  g_pollset = NULL;}

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);}

void grpc_sopb_append(grpc_stream_op_buffer *sopb, grpc_stream_op *ops,                      size_t nops) {  size_t orig_nops = sopb->nops;  size_t new_nops = orig_nops + nops;  if (new_nops > sopb->capacity) {    expandto(sopb, GPR_MAX(GROW(sopb->capacity), new_nops));  }  memcpy(sopb->ops + orig_nops, ops, sizeof(grpc_stream_op) * nops);  sopb->nops = new_nops;}

int grpc_timer_heap_add(grpc_timer_heap *heap, grpc_timer *timer) {  if (heap->timer_count == heap->timer_capacity) {    heap->timer_capacity =        GPR_MAX(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2);    heap->timers =        gpr_realloc(heap->timers, heap->timer_capacity * sizeof(grpc_timer *));  }  timer->heap_index = heap->timer_count;  adjust_upwards(heap->timers, heap->timer_count, timer);  heap->timer_count++;  return timer->heap_index == 0;}

void grpc_chttp2_hpack_compressor_set_max_table_size(    grpc_chttp2_hpack_compressor *c, uint32_t max_table_size) {  max_table_size = GPR_MIN(max_table_size, c->max_usable_size);  if (max_table_size == c->max_table_size) {    return;  }  while (c->table_size > 0 && c->table_size > max_table_size) {    evict_entry(c);  }  c->max_table_size = max_table_size;  c->max_table_elems = elems_for_bytes(max_table_size);  if (c->max_table_elems > c->cap_table_elems) {    rebuild_elems(c, GPR_MAX(c->max_table_elems, 2 * c->cap_table_elems));  } else if (c->max_table_elems < c->cap_table_elems / 3) {    uint32_t new_cap = GPR_MAX(c->max_table_elems, 16);    if (new_cap != c->cap_table_elems) {      rebuild_elems(c, new_cap);    }  }  c->advertise_table_size_change = 1;  gpr_log(GPR_DEBUG, "set max table size from encoder to %d", max_table_size);}

/* Given log size and record size, computes the minimum usable space. */static int32_t min_usable_space(size_t log_size, size_t record_size) {  int32_t usable_space;  int32_t num_blocks =      GPR_MAX(log_size / CENSUS_LOG_MAX_RECORD_SIZE, gpr_cpu_num_cores());  int32_t waste_per_block = CENSUS_LOG_MAX_RECORD_SIZE % record_size;  /* In the worst case, all except one core-local block is full. */  int32_t num_full_blocks = num_blocks - 1;  usable_space = (int32_t)log_size -                 (num_full_blocks * CENSUS_LOG_MAX_RECORD_SIZE) -                 ((num_blocks - num_full_blocks) * waste_per_block);  GPR_ASSERT(usable_space > 0);  return usable_space;}

static void maybe_start_some_streams(    grpc_chttp2_transport_global *transport_global) {  grpc_chttp2_stream_global *stream_global;  /* start streams where we have free grpc_chttp2_stream ids and free   * concurrency */  while (transport_global->next_stream_id <= MAX_CLIENT_STREAM_ID &&         transport_global->concurrent_stream_count <             transport_global                 ->settings[GRPC_PEER_SETTINGS]                           [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] &&         grpc_chttp2_list_pop_waiting_for_concurrency(transport_global,                                                      &stream_global)) {    GRPC_CHTTP2_IF_TRACING(gpr_log(        GPR_DEBUG, "HTTP:%s: Allocating new grpc_chttp2_stream %p to id %d",        transport_global->is_client ? "CLI" : "SVR", stream_global,        transport_global->next_stream_id));    GPR_ASSERT(stream_global->id == 0);    stream_global->id = transport_global->next_stream_id;    transport_global->next_stream_id += 2;    if (transport_global->next_stream_id >= MAX_CLIENT_STREAM_ID) {      connectivity_state_set(transport_global, GRPC_CHANNEL_TRANSIENT_FAILURE,                             "no_more_stream_ids");    }    stream_global->outgoing_window =        transport_global->settings[GRPC_PEER_SETTINGS]                                  [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE];    stream_global->incoming_window =        transport_global->settings[GRPC_SENT_SETTINGS]                                  [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE];    stream_global->max_recv_bytes =         GPR_MAX(stream_global->incoming_window, stream_global->max_recv_bytes);    grpc_chttp2_stream_map_add(        &TRANSPORT_FROM_GLOBAL(transport_global)->new_stream_map,        stream_global->id, STREAM_FROM_GLOBAL(stream_global));    stream_global->in_stream_map = 1;    transport_global->concurrent_stream_count++;    grpc_chttp2_list_add_incoming_window_updated(transport_global,                                                 stream_global);    grpc_chttp2_list_add_writable_stream(transport_global, stream_global);  }  /* cancel out streams that will never be started */  while (transport_global->next_stream_id >= MAX_CLIENT_STREAM_ID &&         grpc_chttp2_list_pop_waiting_for_concurrency(transport_global,                                                      &stream_global)) {    cancel_from_api(transport_global, stream_global, GRPC_STATUS_UNAVAILABLE);  }}