grpc 1.51.0 → 1.52.0.pre2

data/include/grpc/support/string_util.h

@@ -21,7 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/time.h>
 
 #ifdef __cplusplus
 extern "C" {

data/include/grpc/support/sync.h

@@ -19,15 +19,48 @@
 #ifndef GRPC_SUPPORT_SYNC_H
 #define GRPC_SUPPORT_SYNC_H
 
+/* Platform-specific type declarations of gpr_mu and gpr_cv.   */
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/gpr_types.h> /* for gpr_timespec */
-#include <grpc/impl/codegen/sync.h>      // IWYU pragma: export
+#include <grpc/support/time.h> /* for gpr_timespec */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/** Synchronization primitives for GPR.
+
+   The type  gpr_mu              provides a non-reentrant mutex (lock).
+
+   The type  gpr_cv              provides a condition variable.
+
+   The type  gpr_once            provides for one-time initialization.
+
+   The type gpr_event            provides one-time-setting, reading, and
+                                 waiting of a void*, with memory barriers.
+
+   The type gpr_refcount         provides an object reference counter,
+                                 with memory barriers suitable to control
+                                 object lifetimes.
+
+   The type gpr_stats_counter    provides an atomic statistics counter. It
+                                 provides no memory barriers.
+ */
+
+#include <grpc/support/sync_generic.h>  // IWYU pragma: export
+
+#if defined(GPR_CUSTOM_SYNC)
+#include <grpc/support/sync_custom.h>  // IWYU pragma: export
+#elif defined(GPR_ABSEIL_SYNC)
+#include <grpc/support/sync_abseil.h>  // IWYU pragma: export
+#elif defined(GPR_POSIX_SYNC)
+#include <grpc/support/sync_posix.h>  // IWYU pragma: export
+#elif defined(GPR_WINDOWS)
+#include <grpc/support/sync_windows.h>  // IWYU pragma: export
+#else
+#error Unable to determine platform for sync
+#endif
+
 /** --- Mutex interface ---
 
    At most one thread may hold an exclusive lock on a mutex at any given time.

data/include/grpc/support/sync_abseil.h

@@ -21,6 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/sync_abseil.h>  // IWYU pragma: export
+#include <grpc/support/sync_generic.h>
+
+#ifdef GPR_ABSEIL_SYNC
+
+typedef intptr_t gpr_mu;
+typedef intptr_t gpr_cv;
+typedef int32_t gpr_once;
+
+#define GPR_ONCE_INIT 0
+
+#endif
 
 #endif /* GRPC_SUPPORT_SYNC_ABSEIL_H */

data/include/grpc/support/sync_custom.h

@@ -21,6 +21,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/sync_custom.h>  // IWYU pragma: export
+#include <grpc/support/sync_generic.h>
+
+/* Users defining GPR_CUSTOM_SYNC need to define the following macros. */
+
+#ifdef GPR_CUSTOM_SYNC
+
+typedef GPR_CUSTOM_MU_TYPE gpr_mu;
+typedef GPR_CUSTOM_CV_TYPE gpr_cv;
+typedef GPR_CUSTOM_ONCE_TYPE gpr_once;
+
+#define GPR_ONCE_INIT GPR_CUSTOM_ONCE_INIT
+
+#endif
 
 #endif /* GRPC_SUPPORT_SYNC_CUSTOM_H */

data/include/grpc/support/sync_generic.h

@@ -19,8 +19,31 @@
 #ifndef GRPC_SUPPORT_SYNC_GENERIC_H
 #define GRPC_SUPPORT_SYNC_GENERIC_H
 
+/* Generic type definitions for gpr_sync. */
+
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/sync_generic.h>  // IWYU pragma: export
+#include <grpc/support/atm.h>
+
+/* gpr_event */
+typedef struct {
+  gpr_atm state;
+} gpr_event;
+
+#define GPR_EVENT_INIT \
+  { 0 }
+
+/* gpr_refcount */
+typedef struct {
+  gpr_atm count;
+} gpr_refcount;
+
+/* gpr_stats_counter */
+typedef struct {
+  gpr_atm value;
+} gpr_stats_counter;
+
+#define GPR_STATS_INIT \
+  { 0 }
 
 #endif /* GRPC_SUPPORT_SYNC_GENERIC_H */

data/include/grpc/support/sync_posix.h

@@ -21,6 +21,32 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/sync_posix.h>  // IWYU pragma: export
+#include <pthread.h>
+
+#include <grpc/support/sync_generic.h>
+
+#ifdef GRPC_ASAN_ENABLED
+/* The member |leak_checker| is used to check whether there is a memory leak
+ * caused by upper layer logic that's missing the |gpr_xx_destroy| call
+ * to the object before freeing it.
+ * This issue was reported at https://github.com/grpc/grpc/issues/17563
+ * and discussed at https://github.com/grpc/grpc/pull/17586
+ */
+typedef struct {
+  pthread_mutex_t mutex;
+  int* leak_checker;
+} gpr_mu;
+
+typedef struct {
+  pthread_cond_t cond_var;
+  int* leak_checker;
+} gpr_cv;
+#else
+typedef pthread_mutex_t gpr_mu;
+typedef pthread_cond_t gpr_cv;
+#endif
+typedef pthread_once_t gpr_once;
+
+#define GPR_ONCE_INIT PTHREAD_ONCE_INIT
 
 #endif /* GRPC_SUPPORT_SYNC_POSIX_H */

data/include/grpc/support/sync_windows.h

@@ -21,6 +21,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/sync_windows.h>  // IWYU pragma: export
+#ifdef GPR_WINDOWS
+
+#include <grpc/support/sync_generic.h>
+
+typedef struct {
+  CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */
+  int locked;
+} gpr_mu;
+
+typedef CONDITION_VARIABLE gpr_cv;
+
+typedef INIT_ONCE gpr_once;
+#define GPR_ONCE_INIT INIT_ONCE_STATIC_INIT
+
+#endif /* GPR_WINDOWS */
 
 #endif /* GRPC_SUPPORT_SYNC_WINDOWS_H */

data/include/grpc/support/time.h

@@ -24,12 +24,35 @@
 #include <stddef.h>
 #include <time.h>
 
-#include <grpc/impl/codegen/gpr_types.h>
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/** The clocks we support. */
+typedef enum {
+  /** Monotonic clock. Epoch undefined. Always moves forwards. */
+  GPR_CLOCK_MONOTONIC = 0,
+  /** Realtime clock. May jump forwards or backwards. Settable by
+     the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */
+  GPR_CLOCK_REALTIME,
+  /** CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch
+     undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */
+  GPR_CLOCK_PRECISE,
+  /** Unmeasurable clock type: no base, created by taking the difference
+     between two times */
+  GPR_TIMESPAN
+} gpr_clock_type;
+
+/** Analogous to struct timespec. On some machines, absolute times may be in
+ * local time. */
+typedef struct gpr_timespec {
+  int64_t tv_sec;
+  int32_t tv_nsec;
+  /** Against which clock was this time measured? (or GPR_TIMESPAN if
+      this is a relative time measure) */
+  gpr_clock_type clock_type;
+} gpr_timespec;
+
 /** Time constants. */
 GPRAPI gpr_timespec
 gpr_time_0(gpr_clock_type type); /** The zero time interval. */

data/src/core/ext/filters/census/grpc_context.cc

@@ -1,26 +1,25 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
 #include <grpc/census.h>
 #include <grpc/grpc.h>
-#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"

data/src/core/ext/filters/channel_idle/channel_idle_filter.cc

@@ -26,7 +26,7 @@
 
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -94,10 +94,10 @@ struct MaxAgeFilter::Config {
            max_connection_idle != Duration::Infinity();
   }
 
-  /* A random jitter of +/-10% will be added to MAX_CONNECTION_AGE to spread out
-     connection storms. Note that the MAX_CONNECTION_AGE option without jitter
-     would not create connection storms by itself, but if there happened to be a
-     connection storm it could cause it to repeat at a fixed period. */
+  // A random jitter of +/-10% will be added to MAX_CONNECTION_AGE to spread out
+  // connection storms. Note that the MAX_CONNECTION_AGE option without jitter
+  // would not create connection storms by itself, but if there happened to be a
+  // connection storm it could cause it to repeat at a fixed period.
   static Config FromChannelArgs(const ChannelArgs& args) {
     const Duration args_max_age =
         args.GetDurationFromIntMillis(GRPC_ARG_MAX_CONNECTION_AGE_MS)
@@ -108,13 +108,13 @@ struct MaxAgeFilter::Config {
     const Duration args_max_age_grace =
         args.GetDurationFromIntMillis(GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS)
             .value_or(kDefaultMaxConnectionAgeGrace);
-    /* generate a random number between 1 - kMaxConnectionAgeJitter and
-       1 + kMaxConnectionAgeJitter */
+    // generate a random number between 1 - kMaxConnectionAgeJitter and
+    // 1 + kMaxConnectionAgeJitter
     const double multiplier =
         rand() * kMaxConnectionAgeJitter * 2.0 / RAND_MAX + 1.0 -
         kMaxConnectionAgeJitter;
-    /* GRPC_MILLIS_INF_FUTURE - 0.5 converts the value to float, so that result
-       will not be cast to int implicitly before the comparison. */
+    // GRPC_MILLIS_INF_FUTURE - 0.5 converts the value to float, so that result
+    // will not be cast to int implicitly before the comparison.
     return Config{args_max_age * multiplier, args_max_idle, args_max_age_grace};
   }
 };

data/src/core/ext/filters/channel_idle/channel_idle_filter.h

@@ -22,7 +22,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/channel_idle/idle_filter_state.h"
 #include "src/core/lib/channel/channel_args.h"

data/src/core/ext/filters/channel_idle/idle_filter_state.h

@@ -58,7 +58,7 @@ class IdleFilterState {
   static constexpr uintptr_t kCallsInProgressShift = 2;
   // How much to increment/decrement the state_ when a call is started/stopped.
   // Ensures we don't clobber the preceding bits.
-  static constexpr uintptr_t kCallIncrement = uintptr_t(1)
+  static constexpr uintptr_t kCallIncrement = uintptr_t{1}
                                               << kCallsInProgressShift;
   std::atomic<uintptr_t> state_;
 };

data/src/core/ext/filters/client_channel/backend_metric.cc

@@ -68,6 +68,8 @@ const BackendMetricData* ParseBackendMetricData(
       xds_data_orca_v3_OrcaLoadReport_cpu_utilization(msg);
   backend_metric_data->mem_utilization =
       xds_data_orca_v3_OrcaLoadReport_mem_utilization(msg);
+  backend_metric_data->qps =
+      xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
   backend_metric_data->request_cost =
       ParseMap<xds_data_orca_v3_OrcaLoadReport_RequestCostEntry>(
           msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next,

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -166,10 +166,10 @@ void grpc_client_channel_start_backup_polling(
   gpr_mu_lock(&g_poller_mu);
   g_poller_init_locked();
   gpr_ref(&g_poller->refs);
-  /* Get a reference to g_poller->pollset before releasing g_poller_mu to make
-   * TSAN happy. Otherwise, reading from g_poller (i.e g_poller->pollset) after
-   * releasing the lock and setting g_poller to NULL in g_poller_unref() is
-   * being flagged as a data-race by TSAN */
+  // Get a reference to g_poller->pollset before releasing g_poller_mu to make
+  // TSAN happy. Otherwise, reading from g_poller (i.e g_poller->pollset) after
+  // releasing the lock and setting g_poller to NULL in g_poller_unref() is
+  // being flagged as a data-race by TSAN
   grpc_pollset* pollset = g_poller->pollset;
   gpr_mu_unlock(&g_poller_mu);
 

data/src/core/ext/filters/client_channel/backup_poller.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H
@@ -26,15 +26,15 @@
 
 GPR_GLOBAL_CONFIG_DECLARE_INT32(grpc_client_channel_backup_poll_interval_ms);
 
-/* Initializes backup polling. */
+// Initializes backup polling.
 void grpc_client_channel_global_init_backup_polling();
 
-/* Starts polling \a interested_parties periodically in the timer thread. */
+// Starts polling \a interested_parties periodically in the timer thread.
 void grpc_client_channel_start_backup_polling(
     grpc_pollset_set* interested_parties);
 
-/* Stops polling \a interested_parties. */
+// Stops polling \a interested_parties.
 void grpc_client_channel_stop_backup_polling(
     grpc_pollset_set* interested_parties);
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_BACKUP_POLLER_H

data/src/core/ext/filters/client_channel/channel_connectivity.cc

@@ -18,18 +18,22 @@
 
 #include <inttypes.h>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
-#include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/gpr_types.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
@@ -37,7 +41,6 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -112,7 +115,6 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
         state_(last_observed_state) {
     GPR_ASSERT(grpc_cq_begin_op(cq, tag));
     GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
-    GRPC_CLOSURE_INIT(&on_timeout_, TimeoutComplete, this, nullptr);
     ClientChannel* client_channel =
         ClientChannel::GetFromChannel(channel_.get());
     if (client_channel == nullptr) {
@@ -122,19 +124,18 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
       // will always be TRANSIENT_FAILURE), so we don't actually start a
       // watch, but we are hiding that fact from the application.
       if (IsLameChannel(channel_.get())) {
-        // Ref from object creation is held by timer callback.
+        // A ref is held by the timer callback.
         StartTimer(Timestamp::FromTimespecRoundUp(deadline));
+        // Ref from object creation needs to be freed here since lame channel
+        // does not have a watcher.
+        Unref();
         return;
       }
-      gpr_log(GPR_ERROR,
-              "grpc_channel_watch_connectivity_state called on "
-              "something that is not a client channel");
-      GPR_ASSERT(false);
+      Crash(
+          "grpc_channel_watch_connectivity_state called on something that is "
+          "not a client channel");
     }
-    // Take an addition ref, so we have two (the first one is from the
-    // creation of this object).  One will be held by the timer callback,
-    // the other by the watcher callback.
-    Ref().release();
+    // Ref from object creation is held by the watcher callback.
     auto* watcher_timer_init_state = new WatcherTimerInitState(
         this, Timestamp::FromTimespecRoundUp(deadline));
     client_channel->AddExternalConnectivityWatcher(
@@ -167,7 +168,16 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
   };
 
   void StartTimer(Timestamp deadline) {
-    grpc_timer_init(&timer_, deadline, &on_timeout_);
+    const Duration timeout = deadline - Timestamp::Now();
+    absl::MutexLock lock(&mu_);
+    timer_handle_ = channel_->channel_stack()->EventEngine()->RunAfter(
+        timeout, [self = Ref()]() mutable {
+          ApplicationCallbackExecCtx callback_exec_ctx;
+          ExecCtx exec_ctx;
+          self->TimeoutComplete();
+          // StateWatcher deletion might require an active ExecCtx.
+          self.reset();
+        });
   }
 
   static void WatchComplete(void* arg, grpc_error_handle error) {
@@ -175,20 +185,27 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_operation_failures)) {
       GRPC_LOG_IF_ERROR("watch_completion_error", error);
     }
-    grpc_timer_cancel(&self->timer_);
+    {
+      absl::MutexLock lock(&self->mu_);
+      if (self->timer_handle_.has_value()) {
+        self->channel_->channel_stack()->EventEngine()->Cancel(
+            *self->timer_handle_);
+      }
+    }
+    // Watcher fired when either notified or cancelled, either way the state of
+    // this watcher has been cleared from the client channel. Thus there is no
+    // need to cancel the watch again.
     self->Unref();
   }
 
-  static void TimeoutComplete(void* arg, grpc_error_handle error) {
-    auto* self = static_cast<StateWatcher*>(arg);
-    self->timer_fired_ = error.ok();
+  void TimeoutComplete() {
+    timer_fired_ = true;
     // If this is a client channel (not a lame channel), cancel the watch.
     ClientChannel* client_channel =
-        ClientChannel::GetFromChannel(self->channel_.get());
+        ClientChannel::GetFromChannel(channel_.get());
     if (client_channel != nullptr) {
-      client_channel->CancelExternalConnectivityWatcher(&self->on_complete_);
+      client_channel->CancelExternalConnectivityWatcher(&on_complete_);
     }
-    self->Unref();
   }
 
   // Invoked when both strong refs are released.
@@ -217,9 +234,13 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
   grpc_cq_completion completion_storage_;
 
   grpc_closure on_complete_;
-  grpc_timer timer_;
-  grpc_closure on_timeout_;
 
+  // timer_handle_ might be accessed in parallel from multiple threads, e.g.
+  // timer callback fired immediately on an event engine thread before
+  // RunAfter() returns.
+  absl::Mutex mu_;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      timer_handle_ ABSL_GUARDED_BY(mu_);
   bool timer_fired_ = false;
 };