grpc 1.41.0 → 1.42.0.pre1

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -32,7 +32,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -58,10 +57,9 @@ void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error);
 void op_state_machine_locked(inproc_stream* s, grpc_error_handle error);
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial);
-grpc_error_handle fill_in_metadata(inproc_stream* s,
-                                   const grpc_metadata_batch* metadata,
-                                   uint32_t flags, grpc_metadata_batch* out_md,
-                                   uint32_t* outflags, bool* markfilled);
+void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
+                      uint32_t flags, grpc_metadata_batch* out_md,
+                      uint32_t* outflags, bool* markfilled);
 
 struct shared_mu {
   shared_mu() {
@@ -132,11 +130,6 @@ struct inproc_stream {
     ref("inproc_init_stream:init");
     ref("inproc_init_stream:list");
 
-    grpc_metadata_batch_init(&to_read_initial_md);
-    grpc_metadata_batch_init(&to_read_trailing_md);
-    grpc_metadata_batch_init(&write_buffer_initial_md);
-    grpc_metadata_batch_init(&write_buffer_trailing_md);
-
     stream_list_prev = nullptr;
     gpr_mu_lock(&t->mu->mu);
     stream_list_next = t->stream_list;
@@ -172,18 +165,19 @@ struct inproc_stream {
       // Now transfer from the other side's write_buffer if any to the to_read
       // buffer
       if (cs->write_buffer_initial_md_filled) {
-        fill_in_metadata(this, &cs->write_buffer_initial_md,
-                         cs->write_buffer_initial_md_flags, &to_read_initial_md,
-                         &to_read_initial_md_flags, &to_read_initial_md_filled);
-        deadline = GPR_MIN(deadline, cs->write_buffer_deadline);
-        grpc_metadata_batch_clear(&cs->write_buffer_initial_md);
+        (void)fill_in_metadata(this, &cs->write_buffer_initial_md,
+                               cs->write_buffer_initial_md_flags,
+                               &to_read_initial_md, &to_read_initial_md_flags,
+                               &to_read_initial_md_filled);
+        deadline = std::min(deadline, cs->write_buffer_deadline);
+        cs->write_buffer_initial_md.Clear();
         cs->write_buffer_initial_md_filled = false;
       }
       if (cs->write_buffer_trailing_md_filled) {
-        fill_in_metadata(this, &cs->write_buffer_trailing_md, 0,
-                         &to_read_trailing_md, nullptr,
-                         &to_read_trailing_md_filled);
-        grpc_metadata_batch_clear(&cs->write_buffer_trailing_md);
+        (void)fill_in_metadata(this, &cs->write_buffer_trailing_md, 0,
+                               &to_read_trailing_md, nullptr,
+                               &to_read_trailing_md_filled);
+        cs->write_buffer_trailing_md.Clear();
         cs->write_buffer_trailing_md_filled = false;
       }
       if (cs->write_buffer_cancel_error != GRPC_ERROR_NONE) {
@@ -228,28 +222,28 @@ struct inproc_stream {
 #undef STREAM_UNREF
 
   inproc_transport* t;
-  grpc_metadata_batch to_read_initial_md;
+  grpc_stream_refcount* refs;
+  grpc_core::Arena* arena;
+
+  grpc_metadata_batch to_read_initial_md{arena};
   uint32_t to_read_initial_md_flags = 0;
   bool to_read_initial_md_filled = false;
-  grpc_metadata_batch to_read_trailing_md;
+  grpc_metadata_batch to_read_trailing_md{arena};
   bool to_read_trailing_md_filled = false;
   bool ops_needed = false;
   // Write buffer used only during gap at init time when client-side
   // stream is set up but server side stream is not yet set up
-  grpc_metadata_batch write_buffer_initial_md;
+  grpc_metadata_batch write_buffer_initial_md{arena};
   bool write_buffer_initial_md_filled = false;
   uint32_t write_buffer_initial_md_flags = 0;
   grpc_millis write_buffer_deadline = GRPC_MILLIS_INF_FUTURE;
-  grpc_metadata_batch write_buffer_trailing_md;
+  grpc_metadata_batch write_buffer_trailing_md{arena};
   bool write_buffer_trailing_md_filled = false;
   grpc_error_handle write_buffer_cancel_error = GRPC_ERROR_NONE;
 
   struct inproc_stream* other_side;
   bool other_side_closed = false;               // won't talk anymore
   bool write_buffer_other_side_closed = false;  // on hold
-  grpc_stream_refcount* refs;
-
-  grpc_core::Arena* arena;
 
   grpc_transport_stream_op_batch* send_message_op = nullptr;
   grpc_transport_stream_op_batch* send_trailing_md_op = nullptr;
@@ -285,21 +279,51 @@ struct inproc_stream {
 
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial) {
-  for (grpc_linked_mdelem* md = md_batch->list.head; md != nullptr;
-       md = md->next) {
-    char* key = grpc_slice_to_c_string(GRPC_MDKEY(md->md));
-    char* value = grpc_slice_to_c_string(GRPC_MDVALUE(md->md));
+  md_batch->ForEach([=](grpc_mdelem md) {
+    char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
+    char* value = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(GPR_INFO, "INPROC:%s:%s: %s: %s", is_initial ? "HDR" : "TRL",
             is_client ? "CLI" : "SVR", key, value);
     gpr_free(key);
     gpr_free(value);
-  }
+  });
 }
 
-grpc_error_handle fill_in_metadata(inproc_stream* s,
-                                   const grpc_metadata_batch* metadata,
-                                   uint32_t flags, grpc_metadata_batch* out_md,
-                                   uint32_t* outflags, bool* markfilled) {
+namespace {
+
+class CopySink {
+ public:
+  explicit CopySink(grpc_metadata_batch* dst) : dst_(dst) {}
+
+  void Encode(grpc_mdelem md) {
+    // Differently to grpc_metadata_batch_copy, we always copy slices here so
+    // that we don't need to deal with the plethora of edge cases in that world.
+    // TODO(ctiller): revisit this when deleting mdelem.
+    md = grpc_mdelem_from_slices(grpc_slice_intern(GRPC_MDKEY(md)),
+                                 grpc_slice_copy(GRPC_MDVALUE(md)));
+    // Error unused in non-debug builds.
+    grpc_error_handle GRPC_UNUSED error = dst_->Append(md);
+    // The only way that Append() can fail is if
+    // there's a duplicate entry for a callout.  However, that can't be
+    // the case here, because we would not have been allowed to create
+    // a source batch that had that kind of conflict.
+    GPR_DEBUG_ASSERT(error == GRPC_ERROR_NONE);
+  }
+
+  template <class T, class V>
+  void Encode(T trait, V value) {
+    dst_->Set(trait, value);
+  }
+
+ private:
+  grpc_metadata_batch* dst_;
+};
+
+}  // namespace
+
+void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
+                      uint32_t flags, grpc_metadata_batch* out_md,
+                      uint32_t* outflags, bool* markfilled) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
     log_metadata(metadata, s->t->is_client, outflags != nullptr);
   }
@@ -310,18 +334,13 @@ grpc_error_handle fill_in_metadata(inproc_stream* s,
   if (markfilled != nullptr) {
     *markfilled = true;
   }
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  for (grpc_linked_mdelem* elem = metadata->list.head;
-       (elem != nullptr) && (error == GRPC_ERROR_NONE); elem = elem->next) {
-    grpc_linked_mdelem* nelem =
-        static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*nelem)));
-    nelem->md =
-        grpc_mdelem_from_slices(grpc_slice_intern(GRPC_MDKEY(elem->md)),
-                                grpc_slice_intern(GRPC_MDVALUE(elem->md)));
-
-    error = grpc_metadata_batch_link_tail(out_md, nelem);
-  }
-  return error;
+
+  // TODO(ctiller): copy the metadata batch, don't rely on a bespoke copy
+  // function. Can only do this once mdelems are out of the way though, too many
+  // edge cases otherwise.
+  out_md->Clear();
+  CopySink sink(out_md);
+  metadata->Encode(&sink);
 }
 
 int init_stream(grpc_transport* gt, grpc_stream* gs,
@@ -336,8 +355,8 @@ int init_stream(grpc_transport* gt, grpc_stream* gs,
 void close_stream_locked(inproc_stream* s) {
   if (!s->closed) {
     // Release the metadata that we would have written out
-    grpc_metadata_batch_destroy(&s->write_buffer_initial_md);
-    grpc_metadata_batch_destroy(&s->write_buffer_trailing_md);
+    s->write_buffer_initial_md.Clear();
+    s->write_buffer_trailing_md.Clear();
 
     if (s->listed) {
       inproc_stream* p = s->stream_list_prev;
@@ -362,8 +381,8 @@ void close_stream_locked(inproc_stream* s) {
 void close_other_side_locked(inproc_stream* s, const char* reason) {
   if (s->other_side != nullptr) {
     // First release the metadata that came from the other side's arena
-    grpc_metadata_batch_destroy(&s->to_read_initial_md);
-    grpc_metadata_batch_destroy(&s->to_read_trailing_md);
+    s->to_read_initial_md.Clear();
+    s->to_read_trailing_md.Clear();
 
     s->other_side->unref(reason);
     s->other_side_closed = true;
@@ -413,17 +432,14 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     // Send trailing md to the other side indicating cancellation
     s->trailing_md_sent = true;
 
-    grpc_metadata_batch fake_md;
-    grpc_metadata_batch_init(&fake_md);
-
+    grpc_metadata_batch fake_md(s->arena);
     inproc_stream* other = s->other_side;
     grpc_metadata_batch* dest = (other == nullptr)
                                     ? &s->write_buffer_trailing_md
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
-    grpc_metadata_batch_destroy(&fake_md);
+    (void)fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
 
     if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
@@ -439,26 +455,22 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     if (!s->t->is_client) {
       // If this is a server, provide initial metadata with a path and authority
       // since it expects that as well as no error yet
-      grpc_metadata_batch fake_md;
-      grpc_metadata_batch_init(&fake_md);
+      grpc_metadata_batch fake_md(s->arena);
       grpc_linked_mdelem* path_md =
           static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*path_md)));
       path_md->md = grpc_mdelem_from_slices(g_fake_path_key, g_fake_path_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, path_md) ==
-                 GRPC_ERROR_NONE);
+      GPR_ASSERT(fake_md.LinkTail(path_md) == GRPC_ERROR_NONE);
       grpc_linked_mdelem* auth_md =
           static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*auth_md)));
       auth_md->md = grpc_mdelem_from_slices(g_fake_auth_key, g_fake_auth_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, auth_md) ==
-                 GRPC_ERROR_NONE);
+      GPR_ASSERT(fake_md.LinkTail(auth_md) == GRPC_ERROR_NONE);
 
-      fill_in_metadata(
+      (void)fill_in_metadata(
           s, &fake_md, 0,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
           nullptr);
-      grpc_metadata_batch_destroy(&fake_md);
       err = GRPC_ERROR_NONE;
     } else {
       err = GRPC_ERROR_REF(error);
@@ -656,10 +668,11 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
       goto done;
     } else {
       if (!other || !other->closed) {
-        fill_in_metadata(s,
-                         s->send_trailing_md_op->payload->send_trailing_metadata
-                             .send_trailing_metadata,
-                         0, dest, nullptr, destfilled);
+        (void)fill_in_metadata(
+            s,
+            s->send_trailing_md_op->payload->send_trailing_metadata
+                .send_trailing_metadata,
+            0, dest, nullptr, destfilled);
       }
       s->trailing_md_sent = true;
       if (s->send_trailing_md_op->payload->send_trailing_metadata.sent) {
@@ -703,42 +716,34 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
 
     if (s->to_read_initial_md_filled) {
       s->initial_md_recvd = true;
-      new_err = fill_in_metadata(
+      fill_in_metadata(
           s, &s->to_read_initial_md, s->to_read_initial_md_flags,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata,
           s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
           nullptr);
-      s->recv_initial_md_op->payload->recv_initial_metadata
-          .recv_initial_metadata->deadline = s->deadline;
+      if (s->deadline != GRPC_MILLIS_INF_FUTURE) {
+        s->recv_initial_md_op->payload->recv_initial_metadata
+            .recv_initial_metadata->Set(grpc_core::GrpcTimeoutMetadata(),
+                                        s->deadline);
+      }
       if (s->recv_initial_md_op->payload->recv_initial_metadata
               .trailing_metadata_available != nullptr) {
         *s->recv_initial_md_op->payload->recv_initial_metadata
              .trailing_metadata_available =
             (other != nullptr && other->send_trailing_md_op != nullptr);
       }
-      grpc_metadata_batch_clear(&s->to_read_initial_md);
+      s->to_read_initial_md.Clear();
       s->to_read_initial_md_filled = false;
-      INPROC_LOG(GPR_INFO,
-                 "op_state_machine %p scheduling initial-metadata-ready %s", s,
-                 grpc_error_std_string(new_err).c_str());
       grpc_core::ExecCtx::Run(
           DEBUG_LOCATION,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata_ready,
-          GRPC_ERROR_REF(new_err));
+          GRPC_ERROR_NONE);
       complete_if_batch_end_locked(
-          s, new_err, s->recv_initial_md_op,
+          s, GRPC_ERROR_NONE, s->recv_initial_md_op,
           "op_state_machine scheduling recv-initial-metadata-on-complete");
       s->recv_initial_md_op = nullptr;
-
-      if (new_err != GRPC_ERROR_NONE) {
-        INPROC_LOG(GPR_INFO,
-                   "op_state_machine %p scheduling on_complete errors2 %s", s,
-                   grpc_error_std_string(new_err).c_str());
-        fail_helper_locked(s, GRPC_ERROR_REF(new_err));
-        goto done;
-      }
     }
   }
   if (s->recv_message_op) {
@@ -754,7 +759,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
                    "op_state_machine %p already implicitly received trailing "
                    "metadata, so ignoring new trailing metadata from client",
                    s);
-        grpc_metadata_batch_clear(&s->to_read_trailing_md);
+        s->to_read_trailing_md.Clear();
         s->to_read_trailing_md_filled = false;
         s->trailing_md_recvd_implicit_only = false;
       } else {
@@ -796,12 +801,11 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     if (s->recv_trailing_md_op != nullptr) {
       // We wanted trailing metadata and we got it
       s->trailing_md_recvd = true;
-      new_err =
-          fill_in_metadata(s, &s->to_read_trailing_md, 0,
-                           s->recv_trailing_md_op->payload
-                               ->recv_trailing_metadata.recv_trailing_metadata,
-                           nullptr, nullptr);
-      grpc_metadata_batch_clear(&s->to_read_trailing_md);
+      fill_in_metadata(s, &s->to_read_trailing_md, 0,
+                       s->recv_trailing_md_op->payload->recv_trailing_metadata
+                           .recv_trailing_metadata,
+                       nullptr, nullptr);
+      s->to_read_trailing_md.Clear();
       s->to_read_trailing_md_filled = false;
 
       // We should schedule the recv_trailing_md_op completion if
@@ -810,24 +814,16 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
       //    (If the server hasn't already sent its trailing md, it doesn't have
       //     a final status, so don't mark this op complete)
       if (s->t->is_client || s->trailing_md_sent) {
-        INPROC_LOG(GPR_INFO,
-                   "op_state_machine %p scheduling trailing-md-on-complete %s",
-                   s, grpc_error_std_string(new_err).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             s->recv_trailing_md_op->payload->recv_trailing_metadata
                 .recv_trailing_metadata_ready,
-            GRPC_ERROR_REF(new_err));
+            GRPC_ERROR_NONE);
         grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                 s->recv_trailing_md_op->on_complete,
-                                GRPC_ERROR_REF(new_err));
+                                GRPC_ERROR_NONE);
         s->recv_trailing_md_op = nullptr;
         needs_close = s->trailing_md_sent;
-      } else {
-        INPROC_LOG(GPR_INFO,
-                   "op_state_machine %p server needs to delay handling "
-                   "trailing-md-on-complete %s",
-                   s, grpc_error_std_string(new_err).c_str());
       }
     } else if (!s->trailing_md_recvd) {
       INPROC_LOG(
@@ -911,16 +907,14 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
     // already have
     s->trailing_md_sent = true;
 
-    grpc_metadata_batch cancel_md;
-    grpc_metadata_batch_init(&cancel_md);
+    grpc_metadata_batch cancel_md(s->arena);
 
     grpc_metadata_batch* dest = (other == nullptr)
                                     ? &s->write_buffer_trailing_md
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
-    grpc_metadata_batch_destroy(&cancel_md);
+    (void)fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
 
     if (other != nullptr) {
       if (other->cancel_other_error == GRPC_ERROR_NONE) {
@@ -1025,7 +1019,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Extra initial metadata");
       } else {
         if (!s->other_side_closed) {
-          fill_in_metadata(
+          (void)fill_in_metadata(
               s, op->payload->send_initial_metadata.send_initial_metadata,
               op->payload->send_initial_metadata.send_initial_metadata_flags,
               dest, destflags, destfilled);
@@ -1033,8 +1027,10 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
         if (s->t->is_client) {
           grpc_millis* dl =
               (other == nullptr) ? &s->write_buffer_deadline : &other->deadline;
-          *dl = GPR_MIN(*dl, op->payload->send_initial_metadata
-                                 .send_initial_metadata->deadline);
+          *dl = std::min(
+              *dl, op->payload->send_initial_metadata.send_initial_metadata
+                       ->get(grpc_core::GrpcTimeoutMetadata())
+                       .value_or(GRPC_MILLIS_INF_FUTURE));
           s->initial_md_sent = true;
         }
       }

data/src/core/ext/upb-generated/envoy/config/cluster/v3/cluster.upb.c

@@ -49,7 +49,7 @@ const upb_msglayout envoy_config_cluster_v3_ClusterCollection_msginit = {
   UPB_SIZE(8, 16), 1, false, 1, 255,
 };
 
-static const upb_msglayout *const envoy_config_cluster_v3_Cluster_submsgs[34] = {
+static const upb_msglayout *const envoy_config_cluster_v3_Cluster_submsgs[35] = {
   &envoy_config_cluster_v3_CircuitBreakers_msginit,
   &envoy_config_cluster_v3_Cluster_CommonLbConfig_msginit,
   &envoy_config_cluster_v3_Cluster_CustomClusterType_msginit,
@@ -61,6 +61,7 @@ static const upb_msglayout *const envoy_config_cluster_v3_Cluster_submsgs[34] =
   &envoy_config_cluster_v3_Cluster_PreconnectPolicy_msginit,
   &envoy_config_cluster_v3_Cluster_RefreshRate_msginit,
   &envoy_config_cluster_v3_Cluster_RingHashLbConfig_msginit,
+  &envoy_config_cluster_v3_Cluster_RoundRobinLbConfig_msginit,
   &envoy_config_cluster_v3_Cluster_TransportSocketMatch_msginit,
   &envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry_msginit,
   &envoy_config_cluster_v3_Filter_msginit,
@@ -86,63 +87,64 @@ static const upb_msglayout *const envoy_config_cluster_v3_Cluster_submsgs[34] =
   &google_protobuf_UInt32Value_msginit,
 };
 
-static const upb_msglayout_field envoy_config_cluster_v3_Cluster__fields[50] = {
+static const upb_msglayout_field envoy_config_cluster_v3_Cluster__fields[51] = {
   {1, UPB_SIZE(24, 24), 0, 0, 9, _UPB_MODE_SCALAR},
   {2, UPB_SIZE(172, 320), UPB_SIZE(-177, -329), 0, 14, _UPB_MODE_SCALAR},
   {3, UPB_SIZE(40, 56), 1, 3, 11, _UPB_MODE_SCALAR},
-  {4, UPB_SIZE(44, 64), 2, 32, 11, _UPB_MODE_SCALAR},
-  {5, UPB_SIZE(48, 72), 3, 33, 11, _UPB_MODE_SCALAR},
+  {4, UPB_SIZE(44, 64), 2, 33, 11, _UPB_MODE_SCALAR},
+  {5, UPB_SIZE(48, 72), 3, 34, 11, _UPB_MODE_SCALAR},
   {6, UPB_SIZE(4, 4), 0, 0, 14, _UPB_MODE_SCALAR},
-  {8, UPB_SIZE(152, 280), 0, 22, 11, _UPB_MODE_ARRAY},
-  {9, UPB_SIZE(52, 80), 4, 33, 11, _UPB_MODE_SCALAR},
+  {8, UPB_SIZE(152, 280), 0, 23, 11, _UPB_MODE_ARRAY},
+  {9, UPB_SIZE(52, 80), 4, 34, 11, _UPB_MODE_SCALAR},
   {10, UPB_SIZE(56, 88), 5, 0, 11, _UPB_MODE_SCALAR},
-  {13, UPB_SIZE(60, 96), 6, 23, 11, _UPB_MODE_SCALAR},
-  {14, UPB_SIZE(64, 104), 7, 24, 11, _UPB_MODE_SCALAR},
-  {16, UPB_SIZE(68, 112), 8, 32, 11, _UPB_MODE_SCALAR},
+  {13, UPB_SIZE(60, 96), 6, 24, 11, _UPB_MODE_SCALAR},
+  {14, UPB_SIZE(64, 104), 7, 25, 11, _UPB_MODE_SCALAR},
+  {16, UPB_SIZE(68, 112), 8, 33, 11, _UPB_MODE_SCALAR},
   {17, UPB_SIZE(8, 8), 0, 0, 14, _UPB_MODE_SCALAR},
-  {18, UPB_SIZE(156, 288), 0, 18, 11, _UPB_MODE_ARRAY},
-  {19, UPB_SIZE(72, 120), 9, 15, 11, _UPB_MODE_SCALAR},
-  {20, UPB_SIZE(76, 128), 10, 32, 11, _UPB_MODE_SCALAR},
-  {21, UPB_SIZE(80, 136), 11, 19, 11, _UPB_MODE_SCALAR},
+  {18, UPB_SIZE(156, 288), 0, 19, 11, _UPB_MODE_ARRAY},
+  {19, UPB_SIZE(72, 120), 9, 16, 11, _UPB_MODE_SCALAR},
+  {20, UPB_SIZE(76, 128), 10, 33, 11, _UPB_MODE_SCALAR},
+  {21, UPB_SIZE(80, 136), 11, 20, 11, _UPB_MODE_SCALAR},
   {22, UPB_SIZE(84, 144), 12, 4, 11, _UPB_MODE_SCALAR},
   {23, UPB_SIZE(180, 336), UPB_SIZE(-185, -345), 10, 11, _UPB_MODE_SCALAR},
-  {24, UPB_SIZE(88, 152), 13, 27, 11, _UPB_MODE_SCALAR},
-  {25, UPB_SIZE(92, 160), 14, 26, 11, _UPB_MODE_SCALAR},
+  {24, UPB_SIZE(88, 152), 13, 28, 11, _UPB_MODE_SCALAR},
+  {25, UPB_SIZE(92, 160), 14, 27, 11, _UPB_MODE_SCALAR},
   {26, UPB_SIZE(12, 12), 0, 0, 14, _UPB_MODE_SCALAR},
   {27, UPB_SIZE(96, 168), 15, 1, 11, _UPB_MODE_SCALAR},
   {28, UPB_SIZE(32, 40), 0, 0, 9, _UPB_MODE_SCALAR},
-  {29, UPB_SIZE(100, 176), 16, 25, 11, _UPB_MODE_SCALAR},
-  {30, UPB_SIZE(104, 184), 17, 17, 11, _UPB_MODE_SCALAR},
+  {29, UPB_SIZE(100, 176), 16, 26, 11, _UPB_MODE_SCALAR},
+  {30, UPB_SIZE(104, 184), 17, 18, 11, _UPB_MODE_SCALAR},
   {31, UPB_SIZE(16, 16), 0, 0, 8, _UPB_MODE_SCALAR},
   {32, UPB_SIZE(17, 17), 0, 0, 8, _UPB_MODE_SCALAR},
-  {33, UPB_SIZE(108, 192), 18, 30, 11, _UPB_MODE_SCALAR},
+  {33, UPB_SIZE(108, 192), 18, 31, 11, _UPB_MODE_SCALAR},
   {34, UPB_SIZE(180, 336), UPB_SIZE(-185, -345), 7, 11, _UPB_MODE_SCALAR},
-  {36, UPB_SIZE(160, 296), 0, 12, 11, _UPB_MODE_MAP},
+  {36, UPB_SIZE(160, 296), 0, 13, 11, _UPB_MODE_MAP},
   {37, UPB_SIZE(180, 336), UPB_SIZE(-185, -345), 5, 11, _UPB_MODE_SCALAR},
   {38, UPB_SIZE(172, 320), UPB_SIZE(-177, -329), 2, 11, _UPB_MODE_SCALAR},
   {39, UPB_SIZE(18, 18), 0, 0, 8, _UPB_MODE_SCALAR},
-  {40, UPB_SIZE(164, 304), 0, 13, 11, _UPB_MODE_ARRAY},
-  {41, UPB_SIZE(112, 200), 19, 14, 11, _UPB_MODE_SCALAR},
-  {42, UPB_SIZE(116, 208), 20, 20, 11, _UPB_MODE_SCALAR},
-  {43, UPB_SIZE(168, 312), 0, 11, 11, _UPB_MODE_ARRAY},
+  {40, UPB_SIZE(164, 304), 0, 14, 11, _UPB_MODE_ARRAY},
+  {41, UPB_SIZE(112, 200), 19, 15, 11, _UPB_MODE_SCALAR},
+  {42, UPB_SIZE(116, 208), 20, 21, 11, _UPB_MODE_SCALAR},
+  {43, UPB_SIZE(168, 312), 0, 12, 11, _UPB_MODE_ARRAY},
   {44, UPB_SIZE(120, 216), 21, 9, 11, _UPB_MODE_SCALAR},
   {45, UPB_SIZE(19, 19), 0, 0, 8, _UPB_MODE_SCALAR},
-  {46, UPB_SIZE(124, 224), 22, 29, 11, _UPB_MODE_SCALAR},
+  {46, UPB_SIZE(124, 224), 22, 30, 11, _UPB_MODE_SCALAR},
   {47, UPB_SIZE(20, 20), 0, 0, 8, _UPB_MODE_SCALAR},
-  {48, UPB_SIZE(128, 232), 23, 28, 11, _UPB_MODE_SCALAR},
-  {49, UPB_SIZE(132, 240), 24, 16, 11, _UPB_MODE_SCALAR},
+  {48, UPB_SIZE(128, 232), 23, 29, 11, _UPB_MODE_SCALAR},
+  {49, UPB_SIZE(132, 240), 24, 17, 11, _UPB_MODE_SCALAR},
   {50, UPB_SIZE(136, 248), 25, 8, 11, _UPB_MODE_SCALAR},
   {51, UPB_SIZE(21, 21), 0, 0, 8, _UPB_MODE_SCALAR},
   {52, UPB_SIZE(180, 336), UPB_SIZE(-185, -345), 6, 11, _UPB_MODE_SCALAR},
-  {53, UPB_SIZE(140, 256), 26, 21, 11, _UPB_MODE_SCALAR},
-  {54, UPB_SIZE(144, 264), 27, 31, 11, _UPB_MODE_SCALAR},
-  {55, UPB_SIZE(148, 272), 28, 28, 11, _UPB_MODE_SCALAR},
+  {53, UPB_SIZE(140, 256), 26, 22, 11, _UPB_MODE_SCALAR},
+  {54, UPB_SIZE(144, 264), 27, 32, 11, _UPB_MODE_SCALAR},
+  {55, UPB_SIZE(148, 272), 28, 29, 11, _UPB_MODE_SCALAR},
+  {56, UPB_SIZE(180, 336), UPB_SIZE(-185, -345), 11, 11, _UPB_MODE_SCALAR},
 };
 
 const upb_msglayout envoy_config_cluster_v3_Cluster_msginit = {
   &envoy_config_cluster_v3_Cluster_submsgs[0],
   &envoy_config_cluster_v3_Cluster__fields[0],
-  UPB_SIZE(192, 352), 50, false, 6, 255,
+  UPB_SIZE(192, 352), 51, false, 6, 255,
 };
 
 static const upb_msglayout *const envoy_config_cluster_v3_Cluster_TransportSocketMatch_submsgs[2] = {
@@ -226,20 +228,52 @@ const upb_msglayout envoy_config_cluster_v3_Cluster_LbSubsetConfig_LbSubsetSelec
   UPB_SIZE(16, 24), 4, false, 4, 255,
 };
 
-static const upb_msglayout *const envoy_config_cluster_v3_Cluster_LeastRequestLbConfig_submsgs[2] = {
+static const upb_msglayout *const envoy_config_cluster_v3_Cluster_SlowStartConfig_submsgs[2] = {
   &envoy_config_core_v3_RuntimeDouble_msginit,
-  &google_protobuf_UInt32Value_msginit,
+  &google_protobuf_Duration_msginit,
 };
 
-static const upb_msglayout_field envoy_config_cluster_v3_Cluster_LeastRequestLbConfig__fields[2] = {
+static const upb_msglayout_field envoy_config_cluster_v3_Cluster_SlowStartConfig__fields[2] = {
   {1, UPB_SIZE(4, 8), 1, 1, 11, _UPB_MODE_SCALAR},
   {2, UPB_SIZE(8, 16), 2, 0, 11, _UPB_MODE_SCALAR},
 };
 
+const upb_msglayout envoy_config_cluster_v3_Cluster_SlowStartConfig_msginit = {
+  &envoy_config_cluster_v3_Cluster_SlowStartConfig_submsgs[0],
+  &envoy_config_cluster_v3_Cluster_SlowStartConfig__fields[0],
+  UPB_SIZE(16, 24), 2, false, 2, 255,
+};
+
+static const upb_msglayout *const envoy_config_cluster_v3_Cluster_RoundRobinLbConfig_submsgs[1] = {
+  &envoy_config_cluster_v3_Cluster_SlowStartConfig_msginit,
+};
+
+static const upb_msglayout_field envoy_config_cluster_v3_Cluster_RoundRobinLbConfig__fields[1] = {
+  {1, UPB_SIZE(4, 8), 1, 0, 11, _UPB_MODE_SCALAR},
+};
+
+const upb_msglayout envoy_config_cluster_v3_Cluster_RoundRobinLbConfig_msginit = {
+  &envoy_config_cluster_v3_Cluster_RoundRobinLbConfig_submsgs[0],
+  &envoy_config_cluster_v3_Cluster_RoundRobinLbConfig__fields[0],
+  UPB_SIZE(8, 16), 1, false, 1, 255,
+};
+
+static const upb_msglayout *const envoy_config_cluster_v3_Cluster_LeastRequestLbConfig_submsgs[3] = {
+  &envoy_config_cluster_v3_Cluster_SlowStartConfig_msginit,
+  &envoy_config_core_v3_RuntimeDouble_msginit,
+  &google_protobuf_UInt32Value_msginit,
+};
+
+static const upb_msglayout_field envoy_config_cluster_v3_Cluster_LeastRequestLbConfig__fields[3] = {
+  {1, UPB_SIZE(4, 8), 1, 2, 11, _UPB_MODE_SCALAR},
+  {2, UPB_SIZE(8, 16), 2, 1, 11, _UPB_MODE_SCALAR},
+  {3, UPB_SIZE(12, 24), 3, 0, 11, _UPB_MODE_SCALAR},
+};
+
 const upb_msglayout envoy_config_cluster_v3_Cluster_LeastRequestLbConfig_msginit = {
   &envoy_config_cluster_v3_Cluster_LeastRequestLbConfig_submsgs[0],
   &envoy_config_cluster_v3_Cluster_LeastRequestLbConfig__fields[0],
-  UPB_SIZE(16, 24), 2, false, 2, 255,
+  UPB_SIZE(16, 32), 3, false, 3, 255,
 };
 
 static const upb_msglayout *const envoy_config_cluster_v3_Cluster_RingHashLbConfig_submsgs[1] = {