grpc 1.44.0.pre2 → 1.45.0

data/src/core/lib/event_engine/{event_engine_factory.cc → resolved_address.cc}

@@ -14,36 +14,26 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-namespace {
-std::function<std::unique_ptr<EventEngine>()>* g_event_engine_factory = nullptr;
-grpc_core::Mutex* g_mu = new grpc_core::Mutex();
-}  // namespace
-
-EventEngine* GetDefaultEventEngine() {
-  static EventEngine* default_event_engine = CreateEventEngine().release();
-  return default_event_engine;
+EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
+                                              socklen_t size)
+    : size_(size) {
+  GPR_ASSERT(size <= sizeof(address_));
+  memcpy(&address_, address, size);
 }
 
-void SetDefaultEventEngineFactory(
-    std::function<std::unique_ptr<EventEngine>()>* factory) {
-  grpc_core::MutexLock lock(g_mu);
-  g_event_engine_factory = factory;
+const struct sockaddr* EventEngine::ResolvedAddress::address() const {
+  return reinterpret_cast<const struct sockaddr*>(address_);
 }
 
-std::unique_ptr<EventEngine> CreateEventEngine() {
-  grpc_core::MutexLock lock(g_mu);
-  if (g_event_engine_factory == nullptr) {
-    // TODO(hork): call LibuvEventEngineFactory
-    abort();
-  }
-  return (*g_event_engine_factory)();
-}
+socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
 
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/gpr/sync_posix.cc

@@ -131,6 +131,7 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
 #else
     abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
+    abs_deadline = gpr_time_max(abs_deadline, gpr_now(abs_deadline.clock_type));
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;

data/src/core/lib/gpr/time.cc

@@ -184,7 +184,8 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
     dec++;
   }
   if (a.tv_sec == INT64_MAX || a.tv_sec == INT64_MIN) {
-    diff = a;
+    diff.tv_sec = a.tv_sec;
+    diff.tv_nsec = a.tv_nsec;
   } else if (b.tv_sec == INT64_MIN ||
              (b.tv_sec <= 0 && a.tv_sec >= INT64_MAX + b.tv_sec)) {
     diff = gpr_inf_future(GPR_CLOCK_REALTIME);

data/src/core/lib/gpr/useful.h

@@ -106,6 +106,20 @@ constexpr size_t HashPointer(T* p, size_t range) {
          range;
 }
 
+// Compute a+b.
+// If the result is greater than INT64_MAX, return INT64_MAX.
+// If the result is less than INT64_MIN, return INT64_MIN.
+inline int64_t SaturatingAdd(int64_t a, int64_t b) {
+  if (a > 0) {
+    if (b > INT64_MAX - a) {
+      return INT64_MAX;
+    }
+  } else if (b < INT64_MIN - a) {
+    return INT64_MIN;
+  }
+  return a + b;
+}
+
 inline uint32_t MixHash32(uint32_t a, uint32_t b) {
   return RotateLeft(a, 2u) ^ b;
 }

data/src/core/lib/gprpp/capture.h

@@ -0,0 +1,76 @@
+// Copyright 2021 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_LIB_GPRPP_CAPTURE_H
+#define GRPC_CORE_LIB_GPRPP_CAPTURE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <tuple>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+namespace grpc_core {
+
+namespace detail {
+
+template <typename F, typename... Captures>
+class Capture {
+ public:
+  explicit Capture(F f, Captures... captures)
+      : f_(std::move(f)), captures_(std::move(captures)...) {}
+
+  template <typename... Args>
+  decltype(std::declval<F>()(static_cast<Captures*>(nullptr)...,
+                             std::declval<Args>()...))
+  operator()(Args... args) {
+    auto f = &f_;
+    return absl::apply(
+        [f, &args...](Captures&... captures) {
+          return (*f)(&captures..., std::move(args)...);
+        },
+        captures_);
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS F f_;
+  GPR_NO_UNIQUE_ADDRESS std::tuple<Captures...> captures_;
+};
+
+}  // namespace detail
+
+// C++11 helper - best explained by usage:
+//
+// BigThing big_thing;
+// auto f = Capture(
+//             [](BigThing* c, int a, int b) { /*...*/ },
+//             std::move(big_thing));
+//
+// results in: f being a callable that takes arguments (int a, int b), and
+// captures the original value of big_thing by move. Each call, a pointer to
+// each captured thing is inserted into the argument list at the beginning so it
+// can be manipulated.
+//
+// Captured values are mutable, and it's the users responsibility to ensure,
+// should this callable be invoked from different threads, that proper locking
+// is implemented.
+template <typename F, typename... Captures>
+detail::Capture<F, Captures...> Capture(F f, Captures... captures) {
+  return detail::Capture<F, Captures...>(std::move(f), std::move(captures)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CAPTURE_H

data/src/core/lib/gprpp/debug_location.h

@@ -42,6 +42,8 @@ class DebugLocation {
 #else
 class DebugLocation {
  public:
+  DebugLocation() {}
+  DebugLocation(const char* /* file */, int /* line */) {}
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };

data/src/core/lib/gprpp/status_helper.cc

@@ -83,8 +83,6 @@ const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
       return TYPE_URL(TYPE_INT_TAG "channel_connectivity_state");
     case StatusIntProperty::kLbPolicyDrop:
       return TYPE_URL(TYPE_INT_TAG "lb_policy_drop");
-    case StatusIntProperty::kStreamNetworkState:
-      return TYPE_URL(TYPE_INT_TAG "stream_network_state");
   }
   GPR_UNREACHABLE_CODE(return "unknown");
 }
@@ -336,32 +334,34 @@ std::string StatusToString(const absl::Status& status) {
 
 namespace internal {
 
-google_rpc_Status* StatusToProto(const absl::Status& status, upb_arena* arena) {
+google_rpc_Status* StatusToProto(const absl::Status& status, upb_Arena* arena) {
   google_rpc_Status* msg = google_rpc_Status_new(arena);
   google_rpc_Status_set_code(msg, int32_t(status.code()));
   google_rpc_Status_set_message(
-      msg, upb_strview_make(status.message().data(), status.message().size()));
+      msg, upb_StringView_FromDataAndSize(status.message().data(),
+                                          status.message().size()));
   status.ForEachPayload([&](absl::string_view type_url,
                             const absl::Cord& payload) {
     google_protobuf_Any* any = google_rpc_Status_add_details(msg, arena);
     char* type_url_buf =
-        reinterpret_cast<char*>(upb_arena_malloc(arena, type_url.size()));
+        reinterpret_cast<char*>(upb_Arena_Malloc(arena, type_url.size()));
     memcpy(type_url_buf, type_url.data(), type_url.size());
     google_protobuf_Any_set_type_url(
-        any, upb_strview_make(type_url_buf, type_url.size()));
+        any, upb_StringView_FromDataAndSize(type_url_buf, type_url.size()));
     absl::optional<absl::string_view> v_view = payload.TryFlat();
     if (v_view.has_value()) {
       google_protobuf_Any_set_value(
-          any, upb_strview_make(v_view->data(), v_view->size()));
+          any, upb_StringView_FromDataAndSize(v_view->data(), v_view->size()));
     } else {
       char* buf =
-          reinterpret_cast<char*>(upb_arena_malloc(arena, payload.size()));
+          reinterpret_cast<char*>(upb_Arena_Malloc(arena, payload.size()));
       char* cur = buf;
       for (absl::string_view chunk : payload.Chunks()) {
         memcpy(cur, chunk.data(), chunk.size());
         cur += chunk.size();
       }
-      google_protobuf_Any_set_value(any, upb_strview_make(buf, payload.size()));
+      google_protobuf_Any_set_value(
+          any, upb_StringView_FromDataAndSize(buf, payload.size()));
     }
   });
   return msg;
@@ -369,15 +369,15 @@ google_rpc_Status* StatusToProto(const absl::Status& status, upb_arena* arena) {
 
 absl::Status StatusFromProto(google_rpc_Status* msg) {
   int32_t code = google_rpc_Status_code(msg);
-  upb_strview message = google_rpc_Status_message(msg);
+  upb_StringView message = google_rpc_Status_message(msg);
   absl::Status status(static_cast<absl::StatusCode>(code),
                       absl::string_view(message.data, message.size));
   size_t detail_len;
   const google_protobuf_Any* const* details =
       google_rpc_Status_details(msg, &detail_len);
   for (size_t i = 0; i < detail_len; i++) {
-    upb_strview type_url = google_protobuf_Any_type_url(details[i]);
-    upb_strview value = google_protobuf_Any_value(details[i]);
+    upb_StringView type_url = google_protobuf_Any_type_url(details[i]);
+    upb_StringView value = google_protobuf_Any_value(details[i]);
     status.SetPayload(absl::string_view(type_url.data, type_url.size),
                       absl::Cord(absl::string_view(value.data, value.size)));
   }

data/src/core/lib/gprpp/status_helper.h

@@ -31,12 +31,13 @@
 
 extern "C" {
 struct google_rpc_Status;
-struct upb_arena;
+struct upb_Arena;
 }
 
 namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints
+// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusIntProperty {
   /// 'errno' from the operating system
   kErrorNo,
@@ -71,11 +72,10 @@ enum class StatusIntProperty {
   ChannelConnectivityState,
   /// LB policy drop
   kLbPolicyDrop,
-  /// stream network state
-  kStreamNetworkState,
 };
 
 /// This enum should have the same value of grpc_error_strs
+// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusStrProperty {
   /// top-level textual description of this error
   kDescription,
@@ -154,7 +154,7 @@ namespace internal {
 /// Builds a upb message, google_rpc_Status from a status
 /// This is for internal implementation & test only
 google_rpc_Status* StatusToProto(const absl::Status& status,
-                                 upb_arena* arena) GRPC_MUST_USE_RESULT;
+                                 upb_Arena* arena) GRPC_MUST_USE_RESULT;
 
 /// Builds a status from a upb message, google_rpc_Status
 /// This is for internal implementation & test only

data/src/core/lib/gprpp/time.cc

@@ -0,0 +1,186 @@
+// Copyright 2021 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 "src/core/lib/gprpp/time.h"
+
+#include <atomic>
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+namespace {
+
+std::atomic<int64_t> g_process_epoch_seconds;
+std::atomic<gpr_cycle_counter> g_process_epoch_cycles;
+
+GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
+  gpr_cycle_counter cycles_start = 0;
+  gpr_cycle_counter cycles_end = 0;
+  int64_t process_epoch_seconds = 0;
+
+  // Check the current time... if we end up with zero, try again after 100ms.
+  // If it doesn't advance after sleeping for 1100ms, crash the process.
+  for (int i = 0; i < 11; i++) {
+    cycles_start = gpr_get_cycle_counter();
+    gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+    cycles_end = gpr_get_cycle_counter();
+    process_epoch_seconds = now.tv_sec - 1;
+    if (process_epoch_seconds != 0) {
+      break;
+    }
+    gpr_sleep_until(gpr_time_add(now, gpr_time_from_millis(100, GPR_TIMESPAN)));
+  }
+
+  // Time does not seem to be increasing from zero...
+  GPR_ASSERT(process_epoch_seconds != 0);
+  int64_t expected = 0;
+  gpr_cycle_counter process_epoch_cycles = (cycles_start + cycles_end) / 2;
+  GPR_ASSERT(process_epoch_cycles != 0);
+  if (!g_process_epoch_seconds.compare_exchange_strong(
+          expected, process_epoch_seconds, std::memory_order_relaxed,
+          std::memory_order_relaxed)) {
+    process_epoch_seconds = expected;
+    do {
+      process_epoch_cycles =
+          g_process_epoch_cycles.load(std::memory_order_relaxed);
+    } while (process_epoch_cycles == 0);
+  } else {
+    g_process_epoch_cycles.store(process_epoch_cycles,
+                                 std::memory_order_relaxed);
+  }
+  return std::make_pair(process_epoch_seconds, process_epoch_cycles);
+}
+
+gpr_timespec StartTime() {
+  int64_t sec = g_process_epoch_seconds.load(std::memory_order_relaxed);
+  if (GPR_UNLIKELY(sec == 0)) sec = InitTime().first;
+  return {sec, 0, GPR_CLOCK_MONOTONIC};
+}
+
+gpr_cycle_counter StartCycleCounter() {
+  gpr_cycle_counter cycles =
+      g_process_epoch_cycles.load(std::memory_order_relaxed);
+  if (GPR_UNLIKELY(cycles == 0)) cycles = InitTime().second;
+  return cycles;
+}
+
+gpr_timespec MillisecondsAsTimespec(int64_t millis, gpr_clock_type clock_type) {
+  // special-case infinities as Timestamp can be 32bit on some
+  // platforms while gpr_time_from_millis always takes an int64_t.
+  if (millis == std::numeric_limits<int64_t>::max()) {
+    return gpr_inf_future(clock_type);
+  }
+  if (millis == std::numeric_limits<int64_t>::min()) {
+    return gpr_inf_past(clock_type);
+  }
+
+  if (clock_type == GPR_TIMESPAN) {
+    return gpr_time_from_millis(millis, GPR_TIMESPAN);
+  }
+  return gpr_time_add(gpr_convert_clock_type(StartTime(), clock_type),
+                      gpr_time_from_millis(millis, GPR_TIMESPAN));
+}
+
+int64_t TimespanToMillisRoundUp(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type == GPR_TIMESPAN);
+  double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
+             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS +
+             static_cast<double>(GPR_NS_PER_SEC - 1) /
+                 static_cast<double>(GPR_NS_PER_SEC);
+  if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
+    return std::numeric_limits<int64_t>::min();
+  }
+  if (x >= static_cast<double>(std::numeric_limits<int64_t>::max())) {
+    return std::numeric_limits<int64_t>::max();
+  }
+  return static_cast<int64_t>(x);
+}
+
+int64_t TimespanToMillisRoundDown(gpr_timespec ts) {
+  GPR_ASSERT(ts.clock_type == GPR_TIMESPAN);
+  double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
+             static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
+  if (x <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
+    return std::numeric_limits<int64_t>::min();
+  }
+  if (x >= static_cast<double>(std::numeric_limits<int64_t>::max())) {
+    return std::numeric_limits<int64_t>::max();
+  }
+  return static_cast<int64_t>(x);
+}
+
+}  // namespace
+
+Timestamp Timestamp::FromTimespecRoundUp(gpr_timespec ts) {
+  return FromMillisecondsAfterProcessEpoch(TimespanToMillisRoundUp(gpr_time_sub(
+      gpr_convert_clock_type(ts, GPR_CLOCK_MONOTONIC), StartTime())));
+}
+
+Timestamp Timestamp::FromTimespecRoundDown(gpr_timespec ts) {
+  return FromMillisecondsAfterProcessEpoch(
+      TimespanToMillisRoundDown(gpr_time_sub(
+          gpr_convert_clock_type(ts, GPR_CLOCK_MONOTONIC), StartTime())));
+}
+
+Timestamp Timestamp::FromCycleCounterRoundUp(gpr_cycle_counter c) {
+  return Timestamp::FromMillisecondsAfterProcessEpoch(
+      TimespanToMillisRoundUp(gpr_cycle_counter_sub(c, StartCycleCounter())));
+}
+
+Timestamp Timestamp::FromCycleCounterRoundDown(gpr_cycle_counter c) {
+  return Timestamp::FromMillisecondsAfterProcessEpoch(
+      TimespanToMillisRoundDown(gpr_cycle_counter_sub(c, StartCycleCounter())));
+}
+
+gpr_timespec Timestamp::as_timespec(gpr_clock_type clock_type) const {
+  return MillisecondsAsTimespec(millis_, clock_type);
+}
+
+std::string Timestamp::ToString() const {
+  return "@" + std::to_string(millis_) + "ms";
+}
+
+gpr_timespec Duration::as_timespec() const {
+  return MillisecondsAsTimespec(millis_, GPR_TIMESPAN);
+}
+
+Duration Duration::FromTimespec(gpr_timespec t) {
+  return Duration::Milliseconds(TimespanToMillisRoundUp(t));
+}
+
+std::string Duration::ToString() const {
+  return std::to_string(millis_) + "ms";
+}
+
+void TestOnlySetProcessEpoch(gpr_timespec epoch) {
+  g_process_epoch_seconds.store(
+      gpr_convert_clock_type(epoch, GPR_CLOCK_MONOTONIC).tv_sec);
+}
+
+std::ostream& operator<<(std::ostream& out, Timestamp timestamp) {
+  return out << timestamp.ToString();
+}
+
+std::ostream& operator<<(std::ostream& out, Duration duration) {
+  return out << duration.ToString();
+}
+
+}  // namespace grpc_core