grpc 1.27.0 → 1.30.2

data/src/core/lib/surface/channel.h

@@ -21,10 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/metadata.h"
 
 grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* args,
@@ -62,7 +66,30 @@ grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
 size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
 void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 
-struct registered_call;
+namespace grpc_core {
+
+struct RegisteredCall {
+  grpc_mdelem path;
+  grpc_mdelem authority;
+
+  explicit RegisteredCall(const char* method, const char* host);
+  // TODO(vjpai): delete copy constructor once all supported compilers allow
+  //              std::map value_type to be MoveConstructible.
+  RegisteredCall(const RegisteredCall& other);
+  RegisteredCall(RegisteredCall&& other) noexcept;
+
+  ~RegisteredCall();
+};
+
+struct CallRegistrationTable {
+  grpc_core::Mutex mu;
+  std::map<std::pair<const char*, const char*>, RegisteredCall>
+      map /* GUARDED_BY(mu) */;
+  int method_registration_attempts /* GUARDED_BY(mu) */ = 0;
+};
+
+}  // namespace grpc_core
+
 struct grpc_channel {
   int is_client;
   grpc_compression_options compression_options;
@@ -70,9 +97,13 @@ struct grpc_channel {
   gpr_atm call_size_estimate;
   grpc_resource_user* resource_user;
 
-  gpr_mu registered_call_mu;
-  registered_call* registered_calls;
-
+  // TODO(vjpai): Once the grpc_channel is allocated via new rather than malloc,
+  //              expand the members of the CallRegistrationTable directly into
+  //              the grpc_channel. For now it is kept separate so that all the
+  //              manual constructing can be done with a single call rather than
+  //              a separate manual construction for each field.
+  grpc_core::ManualConstructor<grpc_core::CallRegistrationTable>
+      registration_table;
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node;
 
   char* target;

data/src/core/lib/surface/channel_ping.cc

@@ -28,13 +28,12 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/completion_queue.h"
 
-typedef struct {
+struct ping_result {
   grpc_closure closure;
   void* tag;
   grpc_completion_queue* cq;
   grpc_cq_completion completion_storage;
-} ping_result;
-
+};
 static void ping_destroy(void* arg, grpc_cq_completion* /*storage*/) {
   gpr_free(arg);
 }

data/src/core/lib/surface/completion_queue.cc

@@ -23,6 +23,11 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
@@ -56,12 +61,11 @@ namespace {
 GPR_TLS_DECL(g_cached_event);
 GPR_TLS_DECL(g_cached_cq);
 
-typedef struct {
+struct plucker {
   grpc_pollset_worker** worker;
   void* tag;
-} plucker;
-
-typedef struct {
+};
+struct cq_poller_vtable {
   bool can_get_pollset;
   bool can_listen;
   size_t (*size)(void);
@@ -72,8 +76,7 @@ typedef struct {
                       grpc_millis deadline);
   void (*shutdown)(grpc_pollset* pollset, grpc_closure* closure);
   void (*destroy)(grpc_pollset* pollset);
-} cq_poller_vtable;
-
+};
 typedef struct non_polling_worker {
   gpr_cv cv;
   bool kicked;
@@ -81,13 +84,12 @@ typedef struct non_polling_worker {
   struct non_polling_worker* prev;
 } non_polling_worker;
 
-typedef struct {
+struct non_polling_poller {
   gpr_mu mu;
   bool kicked_without_poller;
   non_polling_worker* root;
   grpc_closure* shutdown;
-} non_polling_poller;
-
+};
 size_t non_polling_poller_size(void) { return sizeof(non_polling_poller); }
 
 void non_polling_poller_init(grpc_pollset* pollset, gpr_mu** mu) {
@@ -430,15 +432,14 @@ static const cq_vtable g_cq_vtable[] = {
 
 grpc_core::TraceFlag grpc_cq_pluck_trace(false, "queue_pluck");
 
-#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)      \
-  do {                                                    \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) &&        \
-        (GRPC_TRACE_FLAG_ENABLED(grpc_cq_pluck_trace) ||  \
-         (event)->type != GRPC_QUEUE_TIMEOUT)) {          \
-      char* _ev = grpc_event_string(event);               \
-      gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq, _ev); \
-      gpr_free(_ev);                                      \
-    }                                                     \
+#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)     \
+  do {                                                   \
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) &&       \
+        (GRPC_TRACE_FLAG_ENABLED(grpc_cq_pluck_trace) || \
+         (event)->type != GRPC_QUEUE_TIMEOUT)) {         \
+      gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq,      \
+              grpc_event_string(event).c_str());         \
+    }                                                    \
   } while (0)
 
 static void on_pollset_shutdown_done(void* cq, grpc_error* error);
@@ -874,8 +875,15 @@ static void cq_end_op_for_callback(
     cq_finish_shutdown_callback(cq);
   }
 
+  // If possible, schedule the callback onto an existing thread-local
+  // ApplicationCallbackExecCtx, which is a work queue. This is possible for:
+  // 1. The callback is internally-generated and there is an ACEC available
+  // 2. The callback is marked inlineable and there is an ACEC available
+  // 3. We are already running in a background poller thread (which always has
+  //    an ACEC available at the base of the stack).
   auto* functor = static_cast<grpc_experimental_completion_queue_functor*>(tag);
-  if (internal || functor->inlineable ||
+  if (((internal || functor->inlineable) &&
+       grpc_core::ApplicationCallbackExecCtx::Available()) ||
       grpc_iomgr_is_any_background_poller_thread()) {
     grpc_core::ApplicationCallbackExecCtx::Enqueue(functor,
                                                    (error == GRPC_ERROR_NONE));
@@ -896,15 +904,14 @@ void grpc_cq_end_op(grpc_completion_queue* cq, void* tag, grpc_error* error,
   cq->vtable->end_op(cq, tag, error, done, done_arg, storage, internal);
 }
 
-typedef struct {
+struct cq_is_finished_arg {
   gpr_atm last_seen_things_queued_ever;
   grpc_completion_queue* cq;
   grpc_millis deadline;
   grpc_cq_completion* stolen_completion;
   void* tag; /* for pluck */
   bool first_loop;
-} cq_is_finished_arg;
-
+};
 class ExecCtxNext : public grpc_core::ExecCtx {
  public:
   ExecCtxNext(void* arg) : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
@@ -944,21 +951,14 @@ class ExecCtxNext : public grpc_core::ExecCtx {
 #ifndef NDEBUG
 static void dump_pending_tags(grpc_completion_queue* cq) {
   if (!GRPC_TRACE_FLAG_ENABLED(grpc_trace_pending_tags)) return;
-
-  gpr_strvec v;
-  gpr_strvec_init(&v);
-  gpr_strvec_add(&v, gpr_strdup("PENDING TAGS:"));
+  std::vector<std::string> parts;
+  parts.push_back("PENDING TAGS:");
   gpr_mu_lock(cq->mu);
   for (size_t i = 0; i < cq->outstanding_tag_count; i++) {
-    char* s;
-    gpr_asprintf(&s, " %p", cq->outstanding_tags[i]);
-    gpr_strvec_add(&v, s);
+    parts.push_back(absl::StrFormat(" %p", cq->outstanding_tags[i]));
   }
   gpr_mu_unlock(cq->mu);
-  char* out = gpr_strvec_flatten(&v, nullptr);
-  gpr_strvec_destroy(&v);
-  gpr_log(GPR_DEBUG, "%s", out);
-  gpr_free(out);
+  gpr_log(GPR_DEBUG, "%s", absl::StrJoin(parts, "").c_str());
 }
 #else
 static void dump_pending_tags(grpc_completion_queue* /*cq*/) {}

data/src/core/lib/surface/event_string.cc

@@ -22,47 +22,40 @@
 
 #include <stdio.h>
 
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/byte_buffer.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
 
-static void addhdr(gpr_strvec* buf, grpc_event* ev) {
-  char* tmp;
-  gpr_asprintf(&tmp, "tag:%p", ev->tag);
-  gpr_strvec_add(buf, tmp);
+static void addhdr(grpc_event* ev, std::vector<std::string>* buf) {
+  buf->push_back(absl::StrFormat("tag:%p", ev->tag));
 }
 
 static const char* errstr(int success) { return success ? "OK" : "ERROR"; }
 
-static void adderr(gpr_strvec* buf, int success) {
-  char* tmp;
-  gpr_asprintf(&tmp, " %s", errstr(success));
-  gpr_strvec_add(buf, tmp);
+static void adderr(int success, std::vector<std::string>* buf) {
+  buf->push_back(absl::StrFormat(" %s", errstr(success)));
 }
 
-char* grpc_event_string(grpc_event* ev) {
-  char* out;
-  gpr_strvec buf;
-
-  if (ev == nullptr) return gpr_strdup("null");
-
-  gpr_strvec_init(&buf);
-
+std::string grpc_event_string(grpc_event* ev) {
+  if (ev == nullptr) return "null";
+  std::vector<std::string> out;
   switch (ev->type) {
     case GRPC_QUEUE_TIMEOUT:
-      gpr_strvec_add(&buf, gpr_strdup("QUEUE_TIMEOUT"));
+      out.push_back("QUEUE_TIMEOUT");
       break;
     case GRPC_QUEUE_SHUTDOWN:
-      gpr_strvec_add(&buf, gpr_strdup("QUEUE_SHUTDOWN"));
+      out.push_back("QUEUE_SHUTDOWN");
       break;
     case GRPC_OP_COMPLETE:
-      gpr_strvec_add(&buf, gpr_strdup("OP_COMPLETE: "));
-      addhdr(&buf, ev);
-      adderr(&buf, ev->success);
+      out.push_back("OP_COMPLETE: ");
+      addhdr(ev, &out);
+      adderr(ev->success, &out);
       break;
   }
-
-  out = gpr_strvec_flatten(&buf, nullptr);
-  gpr_strvec_destroy(&buf);
-  return out;
+  return absl::StrJoin(out, "");
 }

data/src/core/lib/surface/event_string.h

@@ -21,9 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include <grpc/grpc.h>
 
 /* Returns a string describing an event. Must be later freed with gpr_free() */
-char* grpc_event_string(grpc_event* ev);
+std::string grpc_event_string(grpc_event* ev);
 
 #endif /* GRPC_CORE_LIB_SURFACE_EVENT_STRING_H */

data/src/core/lib/surface/init_secure.cc

@@ -78,7 +78,4 @@ void grpc_register_security_filters(void) {
                                    maybe_prepend_server_auth_filter, nullptr);
 }
 
-void grpc_security_init() {
-  grpc_core::SecurityRegisterHandshakerFactories();
-  grpc_control_plane_credentials_init();
-}
+void grpc_security_init() { grpc_core::SecurityRegisterHandshakerFactories(); }

data/src/core/lib/surface/server.cc

@@ -52,11 +52,11 @@ grpc_core::TraceFlag grpc_server_channel_trace(false, "server_channel");
 
 using grpc_core::LockedMultiProducerSingleConsumerQueue;
 
-static void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
-static void server_recv_trailing_metadata_ready(void* user_data,
-                                                grpc_error* error);
-
 namespace {
+
+void server_on_recv_initial_metadata(void* ptr, grpc_error* error);
+void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error);
+
 struct listener {
   void* arg;
   void (*start)(grpc_server* server, void* arg, grpc_pollset** pollsets,
@@ -72,17 +72,39 @@ enum requested_call_type { BATCH_CALL, REGISTERED_CALL };
 struct registered_method;
 
 struct requested_call {
-  grpc_core::ManualConstructor<
-      grpc_core::MultiProducerSingleConsumerQueue::Node>
-      mpscq_node;
-  requested_call_type type;
-  size_t cq_idx;
-  void* tag;
-  grpc_server* server;
-  grpc_completion_queue* cq_bound_to_call;
-  grpc_call** call;
+  requested_call(void* tag_arg, grpc_completion_queue* call_cq,
+                 grpc_call** call_arg, grpc_metadata_array* initial_md,
+                 grpc_call_details* details)
+      : type(BATCH_CALL),
+        tag(tag_arg),
+        cq_bound_to_call(call_cq),
+        call(call_arg),
+        initial_metadata(initial_md) {
+    details->reserved = nullptr;
+    data.batch.details = details;
+  }
+
+  requested_call(void* tag_arg, grpc_completion_queue* call_cq,
+                 grpc_call** call_arg, grpc_metadata_array* initial_md,
+                 registered_method* rm, gpr_timespec* deadline,
+                 grpc_byte_buffer** optional_payload)
+      : type(REGISTERED_CALL),
+        tag(tag_arg),
+        cq_bound_to_call(call_cq),
+        call(call_arg),
+        initial_metadata(initial_md) {
+    data.registered.method = rm;
+    data.registered.deadline = deadline;
+    data.registered.optional_payload = optional_payload;
+  }
+
+  grpc_core::MultiProducerSingleConsumerQueue::Node mpscq_node;
+  const requested_call_type type;
+  void* const tag;
+  grpc_completion_queue* const cq_bound_to_call;
+  grpc_call** const call;
   grpc_cq_completion completion;
-  grpc_metadata_array* initial_metadata;
+  grpc_metadata_array* const initial_metadata;
   union {
     struct {
       grpc_call_details* details;
@@ -117,13 +139,13 @@ struct channel_data {
   intptr_t channelz_socket_uuid;
 };
 
-typedef struct shutdown_tag {
+struct shutdown_tag {
   void* tag;
   grpc_completion_queue* cq;
   grpc_cq_completion completion;
-} shutdown_tag;
+};
 
-typedef enum {
+enum call_state {
   /* waiting for metadata */
   NOT_STARTED,
   /* initial metadata read, not flow controlled in yet */
@@ -132,9 +154,60 @@ typedef enum {
   ACTIVATED,
   /* cancelled before being queued */
   ZOMBIED
-} call_state;
+};
 
-typedef struct request_matcher request_matcher;
+struct call_data;
+
+grpc_call_error ValidateServerRequest(
+    grpc_completion_queue* cq_for_notification, void* tag,
+    grpc_byte_buffer** optional_payload, registered_method* rm);
+
+// RPCs that come in from the transport must be matched against RPC requests
+// from the application. An incoming request from the application can be matched
+// to an RPC that has already arrived or can be queued up for later use.
+// Likewise, an RPC coming in from the transport can either be matched to a
+// request that already arrived from the application or can be queued up for
+// later use (marked pending). If there is a match, the request's tag is posted
+// on the request's notification CQ.
+//
+// RequestMatcherInterface is the base class to provide this functionality.
+class RequestMatcherInterface {
+ public:
+  virtual ~RequestMatcherInterface() {}
+
+  // Unref the calls associated with any incoming RPCs in the pending queue (not
+  // yet matched to an application-requested RPC).
+  virtual void ZombifyPending() = 0;
+
+  // Mark all application-requested RPCs failed if they have not been matched to
+  // an incoming RPC. The error parameter indicates why the RPCs are being
+  // failed (always server shutdown in all current implementations).
+  virtual void KillRequests(grpc_error* error) = 0;
+
+  // How many request queues are supported by this matcher. This is an abstract
+  // concept that essentially maps to gRPC completion queues.
+  virtual size_t request_queue_count() const = 0;
+
+  // This function is invoked when the application requests a new RPC whose
+  // information is in the call parameter. The request_queue_index marks the
+  // queue onto which to place this RPC, and is typically associated with a gRPC
+  // CQ. If there are pending RPCs waiting to be matched, publish one (match it
+  // and notify the CQ).
+  virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
+                                              requested_call* call) = 0;
+
+  // This function is invoked on an incoming RPC, represented by the calld
+  // object. The RequestMatcher will try to match it against an
+  // application-requested RPC if possible or will place it in the pending queue
+  // otherwise. To enable some measure of fairness between server CQs, the match
+  // is done starting at the start_request_queue_index parameter in a cyclic
+  // order rather than always starting at 0.
+  virtual void MatchOrQueue(size_t start_request_queue_index,
+                            call_data* calld) = 0;
+
+  // Returns the server associated with this request matcher
+  virtual grpc_server* server() const = 0;
+};
 
 struct call_data {
   call_data(grpc_call_element* elem, const grpc_call_element_args& args)
@@ -144,7 +217,7 @@ struct call_data {
                       ::server_on_recv_initial_metadata, elem,
                       grpc_schedule_on_exec_ctx);
     GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
-                      server_recv_trailing_metadata_ready, elem,
+                      ::server_recv_trailing_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
   }
   ~call_data() {
@@ -177,7 +250,7 @@ struct call_data {
   grpc_metadata_array initial_metadata =
       grpc_metadata_array();  // Zero-initialize the C struct.
 
-  request_matcher* matcher = nullptr;
+  RequestMatcherInterface* matcher = nullptr;
   grpc_byte_buffer* payload = nullptr;
 
   grpc_closure got_initial_metadata;
@@ -196,27 +269,31 @@ struct call_data {
   grpc_core::CallCombiner* call_combiner;
 };
 
-struct request_matcher {
-  grpc_server* server;
-  call_data* pending_head;
-  call_data* pending_tail;
-  LockedMultiProducerSingleConsumerQueue* requests_per_cq;
-};
-
 struct registered_method {
-  char* method;
-  char* host;
-  grpc_server_register_method_payload_handling payload_handling;
-  uint32_t flags;
+  registered_method(
+      const char* method_arg, const char* host_arg,
+      grpc_server_register_method_payload_handling payload_handling_arg,
+      uint32_t flags_arg)
+      : method(method_arg == nullptr ? "" : method_arg),
+        host(host_arg == nullptr ? "" : host_arg),
+        payload_handling(payload_handling_arg),
+        flags(flags_arg) {}
+
+  ~registered_method() = default;
+
+  const std::string method;
+  const std::string host;
+  const grpc_server_register_method_payload_handling payload_handling;
+  const uint32_t flags;
   /* one request matcher per method */
-  request_matcher matcher;
+  std::unique_ptr<RequestMatcherInterface> matcher;
   registered_method* next;
 };
 
-typedef struct {
+struct channel_broadcaster {
   grpc_channel** channels;
   size_t num_channels;
-} channel_broadcaster;
+};
 }  // namespace
 
 struct grpc_server {
@@ -245,9 +322,13 @@ struct grpc_server {
   bool starting;
   gpr_cv starting_cv;
 
+  // TODO(vjpai): Convert from a linked-list head pointer to a std::vector once
+  // grpc_server has a real constructor/destructor
   registered_method* registered_methods;
   /** one request matcher for unregistered methods */
-  request_matcher unregistered_request_matcher;
+  // TODO(vjpai): Convert to a std::unique_ptr once grpc_server has a real
+  // constructor and destructor.
+  RequestMatcherInterface* unregistered_request_matcher;
 
   gpr_atm shutdown_flag;
   uint8_t shutdown_published;
@@ -269,19 +350,26 @@ struct grpc_server {
 #define SERVER_FROM_CALL_ELEM(elem) \
   (((channel_data*)(elem)->channel_data)->server)
 
-static void publish_new_rpc(void* calld, grpc_error* error);
-static void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-                      grpc_error* error);
+namespace {
+void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
+                  requested_call* rc);
+void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
+               grpc_error* error);
 /* Before calling maybe_finish_shutdown, we must hold mu_global and not
    hold mu_call */
-static void maybe_finish_shutdown(grpc_server* server);
+void maybe_finish_shutdown(grpc_server* server);
+
+void kill_zombie(void* elem, grpc_error* /*error*/) {
+  grpc_call_unref(
+      grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
+}
 
 /*
  * channel broadcaster
  */
 
 /* assumes server locked */
-static void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
+void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
   channel_data* c;
   size_t count = 0;
   for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
@@ -302,15 +390,15 @@ struct shutdown_cleanup_args {
   grpc_slice slice;
 };
 
-static void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
+void shutdown_cleanup(void* arg, grpc_error* /*error*/) {
   struct shutdown_cleanup_args* a =
       static_cast<struct shutdown_cleanup_args*>(arg);
   grpc_slice_unref_internal(a->slice);
   gpr_free(a);
 }
 
-static void send_shutdown(grpc_channel* channel, bool send_goaway,
-                          grpc_error* send_disconnect) {
+void send_shutdown(grpc_channel* channel, bool send_goaway,
+                   grpc_error* send_disconnect) {
   struct shutdown_cleanup_args* sc =
       static_cast<struct shutdown_cleanup_args*>(gpr_malloc(sizeof(*sc)));
   GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc,
@@ -331,9 +419,8 @@ static void send_shutdown(grpc_channel* channel, bool send_goaway,
   elem->filter->start_transport_op(elem, op);
 }
 
-static void channel_broadcaster_shutdown(channel_broadcaster* cb,
-                                         bool send_goaway,
-                                         grpc_error* force_disconnect) {
+void channel_broadcaster_shutdown(channel_broadcaster* cb, bool send_goaway,
+                                  grpc_error* force_disconnect) {
   size_t i;
 
   for (i = 0; i < cb->num_channels; i++) {
@@ -349,63 +436,243 @@ static void channel_broadcaster_shutdown(channel_broadcaster* cb,
  * request_matcher
  */
 
-static void request_matcher_init(request_matcher* rm, grpc_server* server) {
-  rm->server = server;
-  rm->pending_head = rm->pending_tail = nullptr;
-  rm->requests_per_cq = static_cast<LockedMultiProducerSingleConsumerQueue*>(
-      gpr_malloc(sizeof(*rm->requests_per_cq) * server->cq_count));
-  for (size_t i = 0; i < server->cq_count; i++) {
-    new (&rm->requests_per_cq[i]) LockedMultiProducerSingleConsumerQueue();
+// The RealRequestMatcher is an implementation of RequestMatcherInterface that
+// actually uses all the features of RequestMatcherInterface: expecting the
+// application to explicitly request RPCs and then matching those to incoming
+// RPCs, along with a slow path by which incoming RPCs are put on a locked
+// pending list if they aren't able to be matched to an application request.
+class RealRequestMatcher : public RequestMatcherInterface {
+ public:
+  explicit RealRequestMatcher(grpc_server* server)
+      : server_(server), requests_per_cq_(server->cq_count) {}
+
+  ~RealRequestMatcher() override {
+    for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
+      GPR_ASSERT(queue.Pop() == nullptr);
+    }
   }
-}
 
-static void request_matcher_destroy(request_matcher* rm) {
-  for (size_t i = 0; i < rm->server->cq_count; i++) {
-    GPR_ASSERT(rm->requests_per_cq[i].Pop() == nullptr);
-    rm->requests_per_cq[i].~LockedMultiProducerSingleConsumerQueue();
+  void ZombifyPending() override {
+    while (pending_head_ != nullptr) {
+      call_data* calld = pending_head_;
+      pending_head_ = calld->pending_next;
+      gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
+      GRPC_CLOSURE_INIT(
+          &calld->kill_zombie_closure, kill_zombie,
+          grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
+          grpc_schedule_on_exec_ctx);
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                              GRPC_ERROR_NONE);
+    }
   }
-  gpr_free(rm->requests_per_cq);
-}
 
-static void kill_zombie(void* elem, grpc_error* /*error*/) {
-  grpc_call_unref(
-      grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
-}
+  void KillRequests(grpc_error* error) override {
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
+      requested_call* rc;
+      while ((rc = reinterpret_cast<requested_call*>(
+                  requests_per_cq_[i].Pop())) != nullptr) {
+        fail_call(server_, i, rc, GRPC_ERROR_REF(error));
+      }
+    }
+    GRPC_ERROR_UNREF(error);
+  }
 
-static void request_matcher_zombify_all_pending_calls(request_matcher* rm) {
-  while (rm->pending_head) {
-    call_data* calld = rm->pending_head;
-    rm->pending_head = calld->pending_next;
-    gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
-    GRPC_CLOSURE_INIT(
-        &calld->kill_zombie_closure, kill_zombie,
-        grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-        grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                            GRPC_ERROR_NONE);
+  size_t request_queue_count() const override {
+    return requests_per_cq_.size();
+  }
+
+  void RequestCallWithPossiblePublish(size_t request_queue_index,
+                                      requested_call* call) override {
+    if (requests_per_cq_[request_queue_index].Push(&call->mpscq_node)) {
+      /* this was the first queued request: we need to lock and start
+         matching calls */
+      gpr_mu_lock(&server_->mu_call);
+      call_data* calld;
+      while ((calld = pending_head_) != nullptr) {
+        requested_call* rc = reinterpret_cast<requested_call*>(
+            requests_per_cq_[request_queue_index].Pop());
+        if (rc == nullptr) break;
+        pending_head_ = calld->pending_next;
+        gpr_mu_unlock(&server_->mu_call);
+        if (!gpr_atm_full_cas(&calld->state, PENDING, ACTIVATED)) {
+          // Zombied Call
+          GRPC_CLOSURE_INIT(
+              &calld->kill_zombie_closure, kill_zombie,
+              grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
+              grpc_schedule_on_exec_ctx);
+          grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
+                                  GRPC_ERROR_NONE);
+        } else {
+          publish_call(server_, calld, request_queue_index, rc);
+        }
+        gpr_mu_lock(&server_->mu_call);
+      }
+      gpr_mu_unlock(&server_->mu_call);
+    }
   }
-}
 
-static void request_matcher_kill_requests(grpc_server* server,
-                                          request_matcher* rm,
-                                          grpc_error* error) {
-  requested_call* rc;
-  for (size_t i = 0; i < server->cq_count; i++) {
-    while ((rc = reinterpret_cast<requested_call*>(
-                rm->requests_per_cq[i].Pop())) != nullptr) {
-      fail_call(server, i, rc, GRPC_ERROR_REF(error));
+  void MatchOrQueue(size_t start_request_queue_index,
+                    call_data* calld) override {
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
+      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
+      requested_call* rc =
+          reinterpret_cast<requested_call*>(requests_per_cq_[cq_idx].TryPop());
+      if (rc == nullptr) {
+        continue;
+      } else {
+        GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
+        gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
+        publish_call(server_, calld, cq_idx, rc);
+        return; /* early out */
+      }
+    }
+
+    /* no cq to take the request found: queue it on the slow list */
+    GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
+    gpr_mu_lock(&server_->mu_call);
+
+    // We need to ensure that all the queues are empty.  We do this under
+    // the server mu_call lock to ensure that if something is added to
+    // an empty request queue, it will block until the call is actually
+    // added to the pending list.
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
+      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
+      requested_call* rc =
+          reinterpret_cast<requested_call*>(requests_per_cq_[cq_idx].Pop());
+      if (rc == nullptr) {
+        continue;
+      } else {
+        gpr_mu_unlock(&server_->mu_call);
+        GRPC_STATS_INC_SERVER_CQS_CHECKED(i + requests_per_cq_.size());
+        gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
+        publish_call(server_, calld, cq_idx, rc);
+        return; /* early out */
+      }
+    }
+
+    gpr_atm_no_barrier_store(&calld->state, PENDING);
+    if (pending_head_ == nullptr) {
+      pending_tail_ = pending_head_ = calld;
+    } else {
+      pending_tail_->pending_next = calld;
+      pending_tail_ = calld;
     }
+    gpr_mu_unlock(&server_->mu_call);
+  }
+
+  grpc_server* server() const override { return server_; }
+
+ private:
+  grpc_server* const server_;
+  call_data* pending_head_ = nullptr;
+  call_data* pending_tail_ = nullptr;
+  std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
+};
+
+// AllocatingRequestMatchers don't allow the application to request an RPC in
+// advance or queue up any incoming RPC for later match. Instead, MatchOrQueue
+// will call out to an allocation function passed in at the construction of the
+// object. These request matchers are designed for the C++ callback API, so they
+// only support 1 completion queue (passed in at the constructor).
+class AllocatingRequestMatcherBase : public RequestMatcherInterface {
+ public:
+  AllocatingRequestMatcherBase(grpc_server* server, grpc_completion_queue* cq)
+      : server_(server), cq_(cq) {
+    size_t idx;
+    for (idx = 0; idx < server->cq_count; idx++) {
+      if (server->cqs[idx] == cq) {
+        break;
+      }
+    }
+    GPR_ASSERT(idx < server->cq_count);
+    cq_idx_ = idx;
+  }
+
+  void ZombifyPending() override {}
+
+  void KillRequests(grpc_error* error) override { GRPC_ERROR_UNREF(error); }
+
+  size_t request_queue_count() const override { return 0; }
+
+  void RequestCallWithPossiblePublish(size_t /*request_queue_index*/,
+                                      requested_call* /*call*/) final {
+    GPR_ASSERT(false);
   }
-  GRPC_ERROR_UNREF(error);
-}
+
+  grpc_server* server() const override { return server_; }
+
+  // Supply the completion queue related to this request matcher
+  grpc_completion_queue* cq() const { return cq_; }
+
+  // Supply the completion queue's index relative to the server.
+  size_t cq_idx() const { return cq_idx_; }
+
+ private:
+  grpc_server* const server_;
+  grpc_completion_queue* const cq_;
+  size_t cq_idx_;
+};
+
+// An allocating request matcher for non-registered methods (used for generic
+// API and unimplemented RPCs).
+class AllocatingRequestMatcherBatch : public AllocatingRequestMatcherBase {
+ public:
+  AllocatingRequestMatcherBatch(
+      grpc_server* server, grpc_completion_queue* cq,
+      std::function<grpc_core::ServerBatchCallAllocation()> allocator)
+      : AllocatingRequestMatcherBase(server, cq),
+        allocator_(std::move(allocator)) {}
+  void MatchOrQueue(size_t /*start_request_queue_index*/,
+                    call_data* calld) override {
+    grpc_core::ServerBatchCallAllocation call_info = allocator_();
+    GPR_ASSERT(ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
+                                     nullptr, nullptr) == GRPC_CALL_OK);
+    requested_call* rc = new requested_call(
+        static_cast<void*>(call_info.tag), cq(), call_info.call,
+        call_info.initial_metadata, call_info.details);
+    gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
+    publish_call(server(), calld, cq_idx(), rc);
+  }
+
+ private:
+  std::function<grpc_core::ServerBatchCallAllocation()> allocator_;
+};
+
+// An allocating request matcher for registered methods.
+class AllocatingRequestMatcherRegistered : public AllocatingRequestMatcherBase {
+ public:
+  AllocatingRequestMatcherRegistered(
+      grpc_server* server, grpc_completion_queue* cq, registered_method* rm,
+      std::function<grpc_core::ServerRegisteredCallAllocation()> allocator)
+      : AllocatingRequestMatcherBase(server, cq),
+        registered_method_(rm),
+        allocator_(std::move(allocator)) {}
+  void MatchOrQueue(size_t /*start_request_queue_index*/,
+                    call_data* calld) override {
+    grpc_core::ServerRegisteredCallAllocation call_info = allocator_();
+    GPR_ASSERT(ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
+                                     call_info.optional_payload,
+                                     registered_method_) == GRPC_CALL_OK);
+    requested_call* rc = new requested_call(
+        static_cast<void*>(call_info.tag), cq(), call_info.call,
+        call_info.initial_metadata, registered_method_, call_info.deadline,
+        call_info.optional_payload);
+    gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
+    publish_call(server(), calld, cq_idx(), rc);
+  }
+
+ private:
+  registered_method* const registered_method_;
+  std::function<grpc_core::ServerRegisteredCallAllocation()> allocator_;
+};
 
 /*
  * server proper
  */
 
-static void server_ref(grpc_server* server) { server->internal_refcount.Ref(); }
+void server_ref(grpc_server* server) { server->internal_refcount.Ref(); }
 
-static void server_delete(grpc_server* server) {
+void server_delete(grpc_server* server) {
   registered_method* rm;
   size_t i;
   server->channelz_server.reset();
@@ -415,16 +682,9 @@ static void server_delete(grpc_server* server) {
   gpr_cv_destroy(&server->starting_cv);
   while ((rm = server->registered_methods) != nullptr) {
     server->registered_methods = rm->next;
-    if (server->started) {
-      request_matcher_destroy(&rm->matcher);
-    }
-    gpr_free(rm->method);
-    gpr_free(rm->host);
-    gpr_free(rm);
-  }
-  if (server->started) {
-    request_matcher_destroy(&server->unregistered_request_matcher);
+    delete rm;
   }
+  delete server->unregistered_request_matcher;
   for (i = 0; i < server->cq_count; i++) {
     GRPC_CQ_INTERNAL_UNREF(server->cqs[i], "server");
   }
@@ -434,30 +694,28 @@ static void server_delete(grpc_server* server) {
   gpr_free(server);
 }
 
-static void server_unref(grpc_server* server) {
+void server_unref(grpc_server* server) {
   if (GPR_UNLIKELY(server->internal_refcount.Unref())) {
     server_delete(server);
   }
 }
 
-static int is_channel_orphaned(channel_data* chand) {
-  return chand->next == chand;
-}
+int is_channel_orphaned(channel_data* chand) { return chand->next == chand; }
 
-static void orphan_channel(channel_data* chand) {
+void orphan_channel(channel_data* chand) {
   chand->next->prev = chand->prev;
   chand->prev->next = chand->next;
   chand->next = chand->prev = chand;
 }
 
-static void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
+void finish_destroy_channel(void* cd, grpc_error* /*error*/) {
   channel_data* chand = static_cast<channel_data*>(cd);
   grpc_server* server = chand->server;
   GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server");
   server_unref(server);
 }
 
-static void destroy_channel(channel_data* chand) {
+void destroy_channel(channel_data* chand) {
   if (is_channel_orphaned(chand)) return;
   GPR_ASSERT(chand->server != nullptr);
   orphan_channel(chand);
@@ -478,12 +736,12 @@ static void destroy_channel(channel_data* chand) {
                        op);
 }
 
-static void done_request_event(void* req, grpc_cq_completion* /*c*/) {
-  gpr_free(req);
+void done_request_event(void* req, grpc_cq_completion* /*c*/) {
+  delete static_cast<requested_call*>(req);
 }
 
-static void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
-                         requested_call* rc) {
+void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
+                  requested_call* rc) {
   grpc_call_set_completion_queue(calld->call, rc->cq_bound_to_call);
   grpc_call* call = calld->call;
   *rc->call = call;
@@ -515,12 +773,12 @@ static void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
                  rc, &rc->completion, true);
 }
 
-static void publish_new_rpc(void* arg, grpc_error* error) {
+void publish_new_rpc(void* arg, grpc_error* error) {
   grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(call_elem->call_data);
   channel_data* chand = static_cast<channel_data*>(call_elem->channel_data);
-  request_matcher* rm = calld->matcher;
-  grpc_server* server = rm->server;
+  RequestMatcherInterface* rm = calld->matcher;
+  grpc_server* server = rm->server();
 
   if (error != GRPC_ERROR_NONE || gpr_atm_acq_load(&server->shutdown_flag)) {
     gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
@@ -533,56 +791,11 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
     return;
   }
 
-  for (size_t i = 0; i < server->cq_count; i++) {
-    size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc =
-        reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].TryPop());
-    if (rc == nullptr) {
-      continue;
-    } else {
-      GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
-      gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-      publish_call(server, calld, cq_idx, rc);
-      return; /* early out */
-    }
-  }
-
-  /* no cq to take the request found: queue it on the slow list */
-  GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
-  gpr_mu_lock(&server->mu_call);
-
-  // We need to ensure that all the queues are empty.  We do this under
-  // the server mu_call lock to ensure that if something is added to
-  // an empty request queue, it will block until the call is actually
-  // added to the pending list.
-  for (size_t i = 0; i < server->cq_count; i++) {
-    size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc =
-        reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
-    if (rc == nullptr) {
-      continue;
-    } else {
-      gpr_mu_unlock(&server->mu_call);
-      GRPC_STATS_INC_SERVER_CQS_CHECKED(i + server->cq_count);
-      gpr_atm_no_barrier_store(&calld->state, ACTIVATED);
-      publish_call(server, calld, cq_idx, rc);
-      return; /* early out */
-    }
-  }
-
-  gpr_atm_no_barrier_store(&calld->state, PENDING);
-  if (rm->pending_head == nullptr) {
-    rm->pending_tail = rm->pending_head = calld;
-  } else {
-    rm->pending_tail->pending_next = calld;
-    rm->pending_tail = calld;
-  }
-  calld->pending_next = nullptr;
-  gpr_mu_unlock(&server->mu_call);
+  rm->MatchOrQueue(chand->cq_idx, calld);
 }
 
-static void finish_start_new_rpc(
-    grpc_server* server, grpc_call_element* elem, request_matcher* rm,
+void finish_start_new_rpc(
+    grpc_server* server, grpc_call_element* elem, RequestMatcherInterface* rm,
     grpc_server_register_method_payload_handling payload_handling) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
 
@@ -615,7 +828,7 @@ static void finish_start_new_rpc(
   }
 }
 
-static void start_new_rpc(grpc_call_element* elem) {
+void start_new_rpc(grpc_call_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_server* server = chand->server;
@@ -640,7 +853,8 @@ static void start_new_rpc(grpc_call_element* elem) {
                 GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
         continue;
       }
-      finish_start_new_rpc(server, elem, &rm->server_registered_method->matcher,
+      finish_start_new_rpc(server, elem,
+                           rm->server_registered_method->matcher.get(),
                            rm->server_registered_method->payload_handling);
       return;
     }
@@ -657,16 +871,17 @@ static void start_new_rpc(grpc_call_element* elem) {
                 GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)) {
         continue;
       }
-      finish_start_new_rpc(server, elem, &rm->server_registered_method->matcher,
+      finish_start_new_rpc(server, elem,
+                           rm->server_registered_method->matcher.get(),
                            rm->server_registered_method->payload_handling);
       return;
     }
   }
-  finish_start_new_rpc(server, elem, &server->unregistered_request_matcher,
+  finish_start_new_rpc(server, elem, server->unregistered_request_matcher,
                        GRPC_SRM_PAYLOAD_NONE);
 }
 
-static int num_listeners(grpc_server* server) {
+int num_listeners(grpc_server* server) {
   listener* l;
   int n = 0;
   for (l = server->listeners; l; l = l->next) {
@@ -675,12 +890,11 @@ static int num_listeners(grpc_server* server) {
   return n;
 }
 
-static void done_shutdown_event(void* server,
-                                grpc_cq_completion* /*completion*/) {
+void done_shutdown_event(void* server, grpc_cq_completion* /*completion*/) {
   server_unref(static_cast<grpc_server*>(server));
 }
 
-static int num_channels(grpc_server* server) {
+int num_channels(grpc_server* server) {
   channel_data* chand;
   int n = 0;
   for (chand = server->root_channel_data.next;
@@ -690,23 +904,20 @@ static int num_channels(grpc_server* server) {
   return n;
 }
 
-static void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
+void kill_pending_work_locked(grpc_server* server, grpc_error* error) {
   if (server->started) {
-    request_matcher_kill_requests(server, &server->unregistered_request_matcher,
-                                  GRPC_ERROR_REF(error));
-    request_matcher_zombify_all_pending_calls(
-        &server->unregistered_request_matcher);
+    server->unregistered_request_matcher->KillRequests(GRPC_ERROR_REF(error));
+    server->unregistered_request_matcher->ZombifyPending();
     for (registered_method* rm = server->registered_methods; rm;
          rm = rm->next) {
-      request_matcher_kill_requests(server, &rm->matcher,
-                                    GRPC_ERROR_REF(error));
-      request_matcher_zombify_all_pending_calls(&rm->matcher);
+      rm->matcher->KillRequests(GRPC_ERROR_REF(error));
+      rm->matcher->ZombifyPending();
     }
   }
   GRPC_ERROR_UNREF(error);
 }
 
-static void maybe_finish_shutdown(grpc_server* server) {
+void maybe_finish_shutdown(grpc_server* server) {
   size_t i;
   if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
     return;
@@ -741,7 +952,7 @@ static void maybe_finish_shutdown(grpc_server* server) {
   }
 }
 
-static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
+void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_millis op_deadline;
@@ -787,8 +998,7 @@ static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
   grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-static void server_recv_trailing_metadata_ready(void* user_data,
-                                                grpc_error* error) {
+void server_recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->on_done_recv_initial_metadata != nullptr) {
@@ -809,8 +1019,8 @@ static void server_recv_trailing_metadata_ready(void* user_data,
                           calld->original_recv_trailing_metadata_ready, error);
 }
 
-static void server_mutate_op(grpc_call_element* elem,
-                             grpc_transport_stream_op_batch* op) {
+void server_mutate_op(grpc_call_element* elem,
+                      grpc_transport_stream_op_batch* op) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
 
   if (op->recv_initial_metadata) {
@@ -832,13 +1042,13 @@ static void server_mutate_op(grpc_call_element* elem,
   }
 }
 
-static void server_start_transport_stream_op_batch(
+void server_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   server_mutate_op(elem, op);
   grpc_call_next_op(elem, op);
 }
 
-static void got_initial_metadata(void* ptr, grpc_error* error) {
+void got_initial_metadata(void* ptr, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
@@ -856,8 +1066,8 @@ static void got_initial_metadata(void* ptr, grpc_error* error) {
   }
 }
 
-static void accept_stream(void* cd, grpc_transport* /*transport*/,
-                          const void* transport_server_data) {
+void accept_stream(void* cd, grpc_transport* /*transport*/,
+                   const void* transport_server_data) {
   channel_data* chand = static_cast<channel_data*>(cd);
   /* create a call */
   grpc_call_create_args args;
@@ -892,25 +1102,25 @@ static void accept_stream(void* cd, grpc_transport* /*transport*/,
   grpc_call_start_batch_and_execute(call, &op, 1, &calld->got_initial_metadata);
 }
 
-static grpc_error* server_init_call_elem(grpc_call_element* elem,
-                                         const grpc_call_element_args* args) {
+grpc_error* server_init_call_elem(grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_ref(chand->server);
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
 }
 
-static void server_destroy_call_elem(grpc_call_element* elem,
-                                     const grpc_call_final_info* /*final_info*/,
-                                     grpc_closure* /*ignored*/) {
+void server_destroy_call_elem(grpc_call_element* elem,
+                              const grpc_call_final_info* /*final_info*/,
+                              grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->~call_data();
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   server_unref(chand->server);
 }
 
-static grpc_error* server_init_channel_elem(grpc_channel_element* elem,
-                                            grpc_channel_element_args* args) {
+grpc_error* server_init_channel_elem(grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
@@ -921,7 +1131,7 @@ static grpc_error* server_init_channel_elem(grpc_channel_element* elem,
   return GRPC_ERROR_NONE;
 }
 
-static void server_destroy_channel_elem(grpc_channel_element* elem) {
+void server_destroy_channel_elem(grpc_channel_element* elem) {
   size_t i;
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (chand->registered_methods) {
@@ -955,6 +1165,115 @@ static void server_destroy_channel_elem(grpc_channel_element* elem) {
   }
 }
 
+void register_completion_queue(grpc_server* server, grpc_completion_queue* cq,
+                               void* reserved) {
+  size_t i, n;
+  GPR_ASSERT(!reserved);
+  for (i = 0; i < server->cq_count; i++) {
+    if (server->cqs[i] == cq) return;
+  }
+
+  GRPC_CQ_INTERNAL_REF(cq, "server");
+  n = server->cq_count++;
+  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
+      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
+  server->cqs[n] = cq;
+}
+
+bool streq(const std::string& a, const char* b) {
+  return (a.empty() && b == nullptr) ||
+         ((b != nullptr) && !strcmp(a.c_str(), b));
+}
+
+class ConnectivityWatcher
+    : public grpc_core::AsyncConnectivityStateWatcherInterface {
+ public:
+  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
+    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
+  }
+
+  ~ConnectivityWatcher() {
+    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
+  }
+
+ private:
+  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+    // Don't do anything until we are being shut down.
+    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
+    // Shut down channel.
+    grpc_server* server = chand_->server;
+    gpr_mu_lock(&server->mu_global);
+    destroy_channel(chand_);
+    gpr_mu_unlock(&server->mu_global);
+  }
+
+  channel_data* chand_;
+};
+
+void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
+  (void)done_arg;
+  gpr_free(storage);
+}
+
+void listener_destroy_done(void* s, grpc_error* /*error*/) {
+  grpc_server* server = static_cast<grpc_server*>(s);
+  gpr_mu_lock(&server->mu_global);
+  server->listeners_destroyed++;
+  maybe_finish_shutdown(server);
+  gpr_mu_unlock(&server->mu_global);
+}
+
+grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
+                                   requested_call* rc) {
+  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+    fail_call(server, cq_idx, rc,
+              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
+    return GRPC_CALL_OK;
+  }
+  RequestMatcherInterface* rm;
+  switch (rc->type) {
+    case BATCH_CALL:
+      rm = server->unregistered_request_matcher;
+      break;
+    case REGISTERED_CALL:
+      rm = rc->data.registered.method->matcher.get();
+      break;
+  }
+  rm->RequestCallWithPossiblePublish(cq_idx, rc);
+  return GRPC_CALL_OK;
+}
+
+void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
+               grpc_error* error) {
+  *rc->call = nullptr;
+  rc->initial_metadata->count = 0;
+  GPR_ASSERT(error != GRPC_ERROR_NONE);
+
+  grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
+                 &rc->completion);
+}
+}  // namespace
+
+namespace grpc_core {
+
+void SetServerRegisteredMethodAllocator(
+    grpc_server* server, grpc_completion_queue* cq, void* method_tag,
+    std::function<ServerRegisteredCallAllocation()> allocator) {
+  registered_method* rm = static_cast<registered_method*>(method_tag);
+  rm->matcher.reset(new AllocatingRequestMatcherRegistered(
+      server, cq, rm, std::move(allocator)));
+}
+
+void SetServerBatchMethodAllocator(
+    grpc_server* server, grpc_completion_queue* cq,
+    std::function<ServerBatchCallAllocation()> allocator) {
+  GPR_DEBUG_ASSERT(server->unregistered_request_matcher == nullptr);
+  server->unregistered_request_matcher =
+      new AllocatingRequestMatcherBatch(server, cq, std::move(allocator));
+}
+
+};  // namespace grpc_core
+
 const grpc_channel_filter grpc_server_top_filter = {
     server_start_transport_stream_op_batch,
     grpc_channel_next_op,
@@ -969,22 +1288,6 @@ const grpc_channel_filter grpc_server_top_filter = {
     "server",
 };
 
-static void register_completion_queue(grpc_server* server,
-                                      grpc_completion_queue* cq,
-                                      void* reserved) {
-  size_t i, n;
-  GPR_ASSERT(!reserved);
-  for (i = 0; i < server->cq_count; i++) {
-    if (server->cqs[i] == cq) return;
-  }
-
-  GRPC_CQ_INTERNAL_REF(cq, "server");
-  n = server->cq_count++;
-  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
-      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
-  server->cqs[n] = cq;
-}
-
 void grpc_server_register_completion_queue(grpc_server* server,
                                            grpc_completion_queue* cq,
                                            void* reserved) {
@@ -1050,13 +1353,6 @@ grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   return server;
 }
 
-static int streq(const char* a, const char* b) {
-  if (a == nullptr && b == nullptr) return 1;
-  if (a == nullptr) return 0;
-  if (b == nullptr) return 0;
-  return 0 == strcmp(a, b);
-}
-
 void* grpc_server_register_method(
     grpc_server* server, const char* method, const char* host,
     grpc_server_register_method_payload_handling payload_handling,
@@ -1083,12 +1379,8 @@ void* grpc_server_register_method(
             flags);
     return nullptr;
   }
-  m = static_cast<registered_method*>(gpr_zalloc(sizeof(registered_method)));
-  m->method = gpr_strdup(method);
-  m->host = gpr_strdup(host);
+  m = new registered_method(method, host, payload_handling, flags);
   m->next = server->registered_methods;
-  m->payload_handling = payload_handling;
-  m->flags = flags;
   server->registered_methods = m;
   return m;
 }
@@ -1109,9 +1401,13 @@ void grpc_server_start(grpc_server* server) {
           grpc_cq_pollset(server->cqs[i]);
     }
   }
-  request_matcher_init(&server->unregistered_request_matcher, server);
+  if (server->unregistered_request_matcher == nullptr) {
+    server->unregistered_request_matcher = new RealRequestMatcher(server);
+  }
   for (registered_method* rm = server->registered_methods; rm; rm = rm->next) {
-    request_matcher_init(&rm->matcher, server);
+    if (rm->matcher == nullptr) {
+      rm->matcher.reset(new RealRequestMatcher(server));
+    }
   }
 
   gpr_mu_lock(&server->mu_global);
@@ -1134,31 +1430,6 @@ void grpc_server_get_pollsets(grpc_server* server, grpc_pollset*** pollsets,
   *pollsets = server->pollsets;
 }
 
-class ConnectivityWatcher
-    : public grpc_core::AsyncConnectivityStateWatcherInterface {
- public:
-  explicit ConnectivityWatcher(channel_data* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel, "connectivity");
-  }
-
-  ~ConnectivityWatcher() {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel, "connectivity");
-  }
-
- private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
-    // Don't do anything until we are being shut down.
-    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
-    // Shut down channel.
-    grpc_server* server = chand_->server;
-    gpr_mu_lock(&server->mu_global);
-    destroy_channel(chand_);
-    gpr_mu_unlock(&server->mu_global);
-  }
-
-  channel_data* chand_;
-};
-
 void grpc_server_setup_transport(
     grpc_server* s, grpc_transport* transport, grpc_pollset* accepting_pollset,
     const grpc_channel_args* args,
@@ -1215,10 +1486,10 @@ void grpc_server_setup_transport(
         static_cast<channel_registered_method*>(gpr_zalloc(alloc));
     for (rm = s->registered_methods; rm; rm = rm->next) {
       grpc_core::ExternallyManagedSlice host;
-      grpc_core::ExternallyManagedSlice method(rm->method);
-      const bool has_host = rm->host != nullptr;
+      grpc_core::ExternallyManagedSlice method(rm->method.c_str());
+      const bool has_host = !rm->host.empty();
       if (has_host) {
-        host = grpc_core::ExternallyManagedSlice(rm->host);
+        host = grpc_core::ExternallyManagedSlice(rm->host.c_str());
       }
       hash = GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash());
       for (probes = 0; chand->registered_methods[(hash + probes) % slots]
@@ -1258,19 +1529,6 @@ void grpc_server_setup_transport(
   grpc_transport_perform_op(transport, op);
 }
 
-void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
-  (void)done_arg;
-  gpr_free(storage);
-}
-
-static void listener_destroy_done(void* s, grpc_error* /*error*/) {
-  grpc_server* server = static_cast<grpc_server*>(s);
-  gpr_mu_lock(&server->mu_global);
-  server->listeners_destroyed++;
-  maybe_finish_shutdown(server);
-  gpr_mu_unlock(&server->mu_global);
-}
-
 /*
   - Kills all pending requests-for-incoming-RPC-calls (i.e the requests made via
     grpc_server_request_call and grpc_server_request_registered call will now be
@@ -1420,59 +1678,51 @@ void grpc_server_add_listener(
   server->listeners = l;
 }
 
-static grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
-                                          requested_call* rc) {
-  call_data* calld = nullptr;
-  request_matcher* rm = nullptr;
-  if (gpr_atm_acq_load(&server->shutdown_flag)) {
-    fail_call(server, cq_idx, rc,
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-    return GRPC_CALL_OK;
+namespace {
+grpc_call_error ValidateServerRequest(
+    grpc_completion_queue* cq_for_notification, void* tag,
+    grpc_byte_buffer** optional_payload, registered_method* rm) {
+  if ((rm == nullptr && optional_payload != nullptr) ||
+      ((rm != nullptr) && ((optional_payload == nullptr) !=
+                           (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)))) {
+    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
   }
-  switch (rc->type) {
-    case BATCH_CALL:
-      rm = &server->unregistered_request_matcher;
-      break;
-    case REGISTERED_CALL:
-      rm = &rc->data.registered.method->matcher;
-      break;
+  if (grpc_cq_begin_op(cq_for_notification, tag) == false) {
+    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
   }
-  if (rm->requests_per_cq[cq_idx].Push(rc->mpscq_node.get())) {
-    /* this was the first queued request: we need to lock and start
-       matching calls */
-    gpr_mu_lock(&server->mu_call);
-    while ((calld = rm->pending_head) != nullptr) {
-      rc = reinterpret_cast<requested_call*>(rm->requests_per_cq[cq_idx].Pop());
-      if (rc == nullptr) break;
-      rm->pending_head = calld->pending_next;
-      gpr_mu_unlock(&server->mu_call);
-      if (!gpr_atm_full_cas(&calld->state, PENDING, ACTIVATED)) {
-        // Zombied Call
-        GRPC_CLOSURE_INIT(
-            &calld->kill_zombie_closure, kill_zombie,
-            grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0),
-            grpc_schedule_on_exec_ctx);
-        grpc_core::ExecCtx::Run(DEBUG_LOCATION, &calld->kill_zombie_closure,
-                                GRPC_ERROR_NONE);
-      } else {
-        publish_call(server, calld, cq_idx, rc);
-      }
-      gpr_mu_lock(&server->mu_call);
+  return GRPC_CALL_OK;
+}
+grpc_call_error ValidateServerRequestAndCq(
+    size_t* cq_idx, grpc_server* server,
+    grpc_completion_queue* cq_for_notification, void* tag,
+    grpc_byte_buffer** optional_payload, registered_method* rm) {
+  size_t idx;
+  for (idx = 0; idx < server->cq_count; idx++) {
+    if (server->cqs[idx] == cq_for_notification) {
+      break;
     }
-    gpr_mu_unlock(&server->mu_call);
   }
+  if (idx == server->cq_count) {
+    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
+  }
+  grpc_call_error error =
+      ValidateServerRequest(cq_for_notification, tag, optional_payload, rm);
+  if (error != GRPC_CALL_OK) {
+    return error;
+  }
+
+  *cq_idx = idx;
   return GRPC_CALL_OK;
 }
+}  // namespace
 
 grpc_call_error grpc_server_request_call(
     grpc_server* server, grpc_call** call, grpc_call_details* details,
     grpc_metadata_array* initial_metadata,
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag) {
-  grpc_call_error error;
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  requested_call* rc = static_cast<requested_call*>(gpr_malloc(sizeof(*rc)));
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   GRPC_API_TRACE(
       "grpc_server_request_call("
@@ -1481,35 +1731,17 @@ grpc_call_error grpc_server_request_call(
       7,
       (server, call, details, initial_metadata, cq_bound_to_call,
        cq_for_notification, tag));
+
   size_t cq_idx;
-  for (cq_idx = 0; cq_idx < server->cq_count; cq_idx++) {
-    if (server->cqs[cq_idx] == cq_for_notification) {
-      break;
-    }
-  }
-  if (cq_idx == server->cq_count) {
-    gpr_free(rc);
-    error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-    goto done;
+  grpc_call_error error = ValidateServerRequestAndCq(
+      &cq_idx, server, cq_for_notification, tag, nullptr, nullptr);
+  if (error != GRPC_CALL_OK) {
+    return error;
   }
-  if (grpc_cq_begin_op(cq_for_notification, tag) == false) {
-    gpr_free(rc);
-    error = GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
-    goto done;
-  }
-  details->reserved = nullptr;
-  rc->cq_idx = cq_idx;
-  rc->type = BATCH_CALL;
-  rc->server = server;
-  rc->tag = tag;
-  rc->cq_bound_to_call = cq_bound_to_call;
-  rc->call = call;
-  rc->data.batch.details = details;
-  rc->initial_metadata = initial_metadata;
-  error = queue_call_request(server, cq_idx, rc);
-done:
-
-  return error;
+
+  requested_call* rc = new requested_call(tag, cq_bound_to_call, call,
+                                          initial_metadata, details);
+  return queue_call_request(server, cq_idx, rc);
 }
 
 grpc_call_error grpc_server_request_registered_call(
@@ -1520,7 +1752,6 @@ grpc_call_error grpc_server_request_registered_call(
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
-  requested_call* rc = static_cast<requested_call*>(gpr_malloc(sizeof(*rc)));
   registered_method* rm = static_cast<registered_method*>(rmp);
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
@@ -1532,48 +1763,18 @@ grpc_call_error grpc_server_request_registered_call(
        cq_bound_to_call, cq_for_notification, tag));
 
   size_t cq_idx;
-  for (cq_idx = 0; cq_idx < server->cq_count; cq_idx++) {
-    if (server->cqs[cq_idx] == cq_for_notification) {
-      break;
-    }
-  }
-  if (cq_idx == server->cq_count) {
-    gpr_free(rc);
-    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-  }
-  if ((optional_payload == nullptr) !=
-      (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)) {
-    gpr_free(rc);
-    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
+  grpc_call_error error = ValidateServerRequestAndCq(
+      &cq_idx, server, cq_for_notification, tag, optional_payload, rm);
+  if (error != GRPC_CALL_OK) {
+    return error;
   }
 
-  if (grpc_cq_begin_op(cq_for_notification, tag) == false) {
-    gpr_free(rc);
-    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
-  }
-  rc->cq_idx = cq_idx;
-  rc->type = REGISTERED_CALL;
-  rc->server = server;
-  rc->tag = tag;
-  rc->cq_bound_to_call = cq_bound_to_call;
-  rc->call = call;
-  rc->data.registered.method = rm;
-  rc->data.registered.deadline = deadline;
-  rc->initial_metadata = initial_metadata;
-  rc->data.registered.optional_payload = optional_payload;
+  requested_call* rc =
+      new requested_call(tag, cq_bound_to_call, call, initial_metadata, rm,
+                         deadline, optional_payload);
   return queue_call_request(server, cq_idx, rc);
 }
 
-static void fail_call(grpc_server* server, size_t cq_idx, requested_call* rc,
-                      grpc_error* error) {
-  *rc->call = nullptr;
-  rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
-
-  grpc_cq_end_op(server->cqs[cq_idx], rc->tag, error, done_request_event, rc,
-                 &rc->completion);
-}
-
 const grpc_channel_args* grpc_server_get_channel_args(grpc_server* server) {
   return server->channel_args;
 }