grpc 1.48.0 → 1.50.0

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

@@ -0,0 +1,94 @@
+// Copyright 2022 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_NO_DESTRUCT_H
+#define GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "src/core/lib/gprpp/construct_destruct.h"
+
+namespace grpc_core {
+
+// NoDestruct<T> is a wrapper around an object of type T that:
+// - stores the value inline - no heap allocation
+// - is non-copyable
+// - is eagerly constructed (i.e. the constructor is called when NoDestruct is
+//   constructed)
+// - *NEVER* calls ~T()
+// It's useful in cases where no ordering can be assumed between destructors of
+// objects that need to refer to each other - such as at program destruction
+// time.
+// Examples:
+//  // globally available object:
+//  static NoDestruct<Foo> g_foo(1, "foo", 2.0);
+//  // used as:
+//  g_foo->DoSomething();
+//  // singleton function:
+//  Bar* BarSingleton() {
+//   static NoDestruct<Bar> bar(1, "bar", 2.0);
+//   return &*bar;
+//  }
+// The globally available version is constructed at program startup, and the
+// singleton version is constructed at the first call to BarSingleton().
+// Neither Foo nor Bar instance will be destructed.
+template <typename T>
+class NoDestruct {
+ public:
+  template <typename... Args>
+  explicit NoDestruct(Args&&... args) {
+    static_assert(std::is_trivially_destructible<NoDestruct<T>>::value,
+                  "NoDestruct must be trivially destructible");
+    Construct(reinterpret_cast<T*>(&space_), std::forward<Args>(args)...);
+  }
+  NoDestruct(const NoDestruct&) = delete;
+  NoDestruct& operator=(const NoDestruct&) = delete;
+  ~NoDestruct() = default;
+
+  T* operator->() { return get(); }
+  const T* operator->() const { return get(); }
+  T& operator*() { return *get(); }
+  const T& operator*() const { return *get(); }
+
+  T* get() { return reinterpret_cast<T*>(&space_); }
+  const T* get() const { return reinterpret_cast<const T*>(&space_); }
+
+ private:
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type space_;
+};
+
+// Helper for when a program desires a single *process wide* instance of a
+// default constructed T to be always available.
+// The instance is constructed eagerly at program startup, so it's essentially
+// free to load the pointer to the instance.
+template <typename T>
+class NoDestructSingleton {
+ public:
+  static T* Get() { return &*value_; }
+
+ private:
+  NoDestructSingleton() = delete;
+  ~NoDestructSingleton() = delete;
+
+  static NoDestruct<T> value_;
+};
+
+template <typename T>
+NoDestruct<T> NoDestructSingleton<T>::value_;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_NO_DESTRUCT_H

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

@@ -0,0 +1,67 @@
+// Copyright 2022 The 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_NOTIFICATION_H
+#define GRPC_CORE_LIB_GPRPP_NOTIFICATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_core {
+
+// Polyfill for absl::Notification until we can use that type.
+class Notification {
+ public:
+  void Notify() {
+    MutexLock lock(&mu_);
+    notified_ = true;
+    cv_.SignalAll();
+  }
+
+  void WaitForNotification() {
+    MutexLock lock(&mu_);
+    while (!notified_) {
+      cv_.Wait(&mu_);
+    }
+  }
+
+  bool WaitForNotificationWithTimeout(absl::Duration timeout) {
+    auto now = absl::Now();
+    auto deadline = now + timeout;
+    MutexLock lock(&mu_);
+    while (!notified_ && now < deadline) {
+      cv_.WaitWithTimeout(&mu_, deadline - now);
+      now = absl::Now();
+    }
+    return notified_;
+  }
+
+  bool HasBeenNotified() {
+    MutexLock lock(&mu_);
+    return notified_;
+  }
+
+ private:
+  Mutex mu_;
+  CondVar cv_;
+  bool notified_ = false;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_NOTIFICATION_H

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

@@ -0,0 +1,40 @@
+// Copyright 2022 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_PACKED_TABLE_H
+#define GRPC_CORE_LIB_GPRPP_PACKED_TABLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/sorted_pack.h"
+#include "src/core/lib/gprpp/table.h"
+
+namespace grpc_core {
+
+namespace packed_table_detail {
+template <typename A, typename B>
+struct Cmp {
+  static constexpr bool kValue = alignof(A) > alignof(B) ||
+                                 (alignof(A) == alignof(B) &&
+                                  sizeof(A) > sizeof(B));
+};
+};  // namespace packed_table_detail
+
+template <typename... T>
+using PackedTable =
+    typename WithSortedPack<Table, packed_table_detail::Cmp, T...>::Type;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_PACKED_TABLE_H

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include <iosfwd>
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/debug_location.h"
@@ -56,14 +55,12 @@ class RefCountedPtr {
 
   // Move assignment.
   RefCountedPtr& operator=(RefCountedPtr&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
   template <typename Y>
   RefCountedPtr& operator=(RefCountedPtr<Y>&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
 
@@ -109,39 +106,32 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   void reset(T* value = nullptr) {
-    if (value_ != nullptr) value_->Unref();
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->Unref();
   }
   void reset(const DebugLocation& location, const char* reason,
              T* value = nullptr) {
-    if (value_ != nullptr) value_->Unref(location, reason);
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->Unref(location, reason);
   }
   template <typename Y>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->Unref();
-    value_ = static_cast<T*>(value);
+    reset(static_cast<T*>(value));
   }
   template <typename Y>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->Unref(location, reason);
-    value_ = static_cast<T*>(value);
+    reset(location, reason, static_cast<T*>(value));
   }
 
-  // TODO(roth): This method exists solely as a transition mechanism to allow
-  // us to pass a ref to idiomatic C code that does not use RefCountedPtr<>.
-  // Once all of our code has been converted to idiomatic C++, this
-  // method should go away.
-  T* release() {
-    T* value = value_;
-    value_ = nullptr;
-    return value;
-  }
+  // This method is mostly useful for interoperating with C code.
+  // Eventually use within core should be banned, except at the surface API
+  // boundaries.
+  T* release() { return std::exchange(value_, nullptr); }
 
   T* get() const { return value_; }
 
@@ -208,14 +198,12 @@ class WeakRefCountedPtr {
 
   // Move assignment.
   WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
   template <typename Y>
   WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) noexcept {
-    reset(other.value_);
-    other.value_ = nullptr;
+    reset(std::exchange(other.value_, nullptr));
     return *this;
   }
 
@@ -261,28 +249,26 @@ class WeakRefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   void reset(T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->WeakUnref();
   }
   void reset(const DebugLocation& location, const char* reason,
              T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = value;
+    T* old_value = std::exchange(value_, value);
+    if (old_value != nullptr) old_value->WeakUnref(location, reason);
   }
   template <typename Y>
   void reset(Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = static_cast<T*>(value);
+    reset(static_cast<T*>(value));
   }
   template <typename Y>
   void reset(const DebugLocation& location, const char* reason,
              Y* value = nullptr) {
     static_assert(std::has_virtual_destructor<T>::value,
                   "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = static_cast<T*>(value);
+    reset(location, reason, static_cast<T*>(value));
   }
 
   // TODO(roth): This method exists solely as a transition mechanism to allow

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

@@ -0,0 +1,98 @@
+// Copyright 2022 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_SORTED_PACK_H
+#define GRPC_CORE_LIB_GPRPP_SORTED_PACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+
+namespace grpc_core {
+
+namespace sorted_pack_detail {
+
+// A list of types
+template <typename... A>
+struct Typelist {
+  template <template <typename...> class T>
+  using Instantiate = T<A...>;
+
+  template <typename C>
+  using PushFront = Typelist<C, A...>;
+};
+
+// Find the smallest element of Args, and the rest of the elements
+template <template <typename, typename> class Cmp, typename Args>
+struct Smallest;
+
+template <template <typename, typename> class Cmp, typename Arg,
+          typename... Args>
+struct Smallest<Cmp, Typelist<Arg, Args...>> {
+  using SmallestRest = Smallest<Cmp, Typelist<Args...>>;
+  using PrevSmallest = typename SmallestRest::Result;
+  using PrevRest = typename SmallestRest::Rest;
+  static constexpr bool kCmpResult = Cmp<Arg, PrevSmallest>::kValue;
+  using Result = typename std::conditional<kCmpResult, Arg, PrevSmallest>::type;
+  using Prefix = typename std::conditional<kCmpResult, PrevSmallest, Arg>::type;
+  using Rest = typename PrevRest::template PushFront<Prefix>;
+};
+
+template <template <typename, typename> class Cmp, typename Arg>
+struct Smallest<Cmp, Typelist<Arg>> {
+  using Result = Arg;
+  using Rest = Typelist<>;
+};
+
+// Sort a list of types into a typelist
+template <template <typename, typename> class Cmp, typename Args>
+struct Sorted;
+
+template <template <typename, typename> class Cmp, typename... Args>
+struct Sorted<Cmp, Typelist<Args...>> {
+  using SmallestResult = Smallest<Cmp, Typelist<Args...>>;
+  using SmallestType = typename SmallestResult::Result;
+  using RestOfTypes = typename SmallestResult::Rest;
+  using SortedRestOfTypes = typename Sorted<Cmp, RestOfTypes>::Result;
+  using Result = typename SortedRestOfTypes::template PushFront<SmallestType>;
+};
+
+template <template <typename, typename> class Cmp, typename Arg>
+struct Sorted<Cmp, Typelist<Arg>> {
+  using Result = Typelist<Arg>;
+};
+
+template <template <typename, typename> class Cmp>
+struct Sorted<Cmp, Typelist<>> {
+  using Result = Typelist<>;
+};
+
+}  // namespace sorted_pack_detail
+
+// Given a type T<A...>, and a type comparator Cmp<P,Q>, and some set of types
+// Args...:
+// Sort Args... using Cmp into SortedArgs..., then instantiate T<SortedArgs...>
+// as Type.
+// Cmp<P,Q> should have a single constant `kValue` that is true if P < Q.
+template <template <typename...> class T,
+          template <typename, typename> class Cmp, typename... Args>
+struct WithSortedPack {
+  using Type = typename sorted_pack_detail::Sorted<
+      Cmp,
+      sorted_pack_detail::Typelist<Args...>>::Result::template Instantiate<T>;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_SORTED_PACK_H

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

@@ -34,6 +34,7 @@
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
+#include "upb/arena.h"
 #include "upb/upb.h"
 #include "upb/upb.hpp"
 

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

@@ -38,6 +38,12 @@ struct google_rpc_Status;
 struct upb_Arena;
 }
 
+#define RETURN_IF_ERROR(expr)           \
+  do {                                  \
+    const absl::Status status = (expr); \
+    if (!status.ok()) return status;    \
+  } while (0)
+
 namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints

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

@@ -21,7 +21,6 @@
 
 #include <initializer_list>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -219,7 +218,7 @@ class Table {
 
   // Check if this table has index I.
   template <size_t I>
-      absl::enable_if_t < I<sizeof...(Ts), bool> has() const {
+  absl::enable_if_t<(I < sizeof...(Ts)), bool> has() const {
     return present_bits_.is_set(I);
   }
 
@@ -318,6 +317,14 @@ class Table {
     ForEachImpl(std::move(f), absl::make_index_sequence<sizeof...(Ts)>());
   }
 
+  // Iterate through each set field in the table if it exists in Vs, in the
+  // order of Vs.
+  template <typename F, typename... Vs>
+  void ForEachIn(F f) const {
+    ForEachImpl(std::move(f),
+                absl::index_sequence<table_detail::IndexOf<Vs, Ts...>()...>());
+  }
+
   // Count the number of set fields in the table
   size_t count() const { return present_bits_.count(); }
 

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

@@ -0,0 +1,49 @@
+// Copyright 2022 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/tchar.h"
+
+#ifdef GPR_WINDOWS
+
+namespace grpc_core {
+
+#if defined UNICODE || defined _UNICODE
+TcharString CharToTchar(std::string input) {
+  int needed = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0);
+  if (needed <= 0) return TcharString();
+  TcharString ret(needed, L'\0');
+  MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1,
+                      const_cast<LPTSTR>(ret.data()), needed);
+  return ret;
+}
+
+std::string TcharToChar(TcharString input) {
+  int needed =
+      WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1, NULL, 0, NULL, NULL);
+  if (needed <= 0) return std::string();
+  std::string ret(needed, '\0');
+  WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1,
+                      const_cast<LPSTR>(ret.data()), needed, NULL, NULL);
+  return ret;
+}
+#else
+TcharString CharToTchar(std::string input) { return input; }
+std::string TcharToChar(TcharString input) { return input; }
+#endif
+
+}  // namespace grpc_core
+
+#endif

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

@@ -0,0 +1,33 @@
+// Copyright 2022 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_TCHAR_H
+#define GRPC_CORE_LIB_GPRPP_TCHAR_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+#include <string>
+
+namespace grpc_core {
+
+using TcharString = std::basic_string<TCHAR>;
+
+TcharString CharToTchar(std::string input);
+std::string TcharToChar(TcharString input);
+
+}  // namespace grpc_core
+#endif
+
+#endif  // GRPC_CORE_LIB_GPRPP_TCHAR_H

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

@@ -28,6 +28,8 @@
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/no_destruct.h"
+
 namespace grpc_core {
 
 namespace {
@@ -35,6 +37,13 @@ namespace {
 std::atomic<int64_t> g_process_epoch_seconds;
 std::atomic<gpr_cycle_counter> g_process_epoch_cycles;
 
+class GprNowTimeSource final : public Timestamp::Source {
+ public:
+  Timestamp Now() override {
+    return Timestamp::FromTimespecRoundDown(gpr_now(GPR_CLOCK_MONOTONIC));
+  }
+};
+
 GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
   gpr_cycle_counter cycles_start = 0;
   gpr_cycle_counter cycles_end = 0;
@@ -133,6 +142,18 @@ int64_t TimespanToMillisRoundDown(gpr_timespec ts) {
 
 }  // namespace
 
+GPR_THREAD_LOCAL(Timestamp::Source*)
+Timestamp::thread_local_time_source_{
+    NoDestructSingleton<GprNowTimeSource>::Get()};
+
+Timestamp ScopedTimeCache::Now() {
+  if (!cached_time_.has_value()) {
+    previous()->InvalidateCache();
+    cached_time_ = previous()->Now();
+  }
+  return cached_time_.value();
+}
+
 Timestamp Timestamp::FromTimespecRoundUp(gpr_timespec ts) {
   return FromMillisecondsAfterProcessEpoch(TimespanToMillisRoundUp(gpr_time_sub(
       gpr_convert_clock_type(ts, GPR_CLOCK_MONOTONIC), StartTime())));