grpc 1.41.1 → 1.44.0.pre2

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

@@ -0,0 +1,253 @@
+// 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_CHUNKED_VECTOR_H
+#define GRPC_CORE_LIB_GPRPP_CHUNKED_VECTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+
+#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Arena-friendly vector type.
+// This "vector" allocates non-contiguous runs of kChunkSize T's at a time.
+// Expectation is that most usage will fit in one chunk, sometimes two will be
+// needed, and very rarely three. Appending is constant time, calculating the
+// size is O(n_chunks).
+template <typename T, size_t kChunkSize>
+class ChunkedVector {
+ private:
+  // One chunk of allocated memory.
+  struct Chunk {
+    Chunk() = default;
+    Chunk* next = nullptr;
+    size_t count = 0;
+    ManualConstructor<T> data[kChunkSize];
+  };
+
+ public:
+  explicit ChunkedVector(Arena* arena) : arena_(arena) {}
+  template <class Iterator>
+  ChunkedVector(Arena* arena, Iterator begin, Iterator end) : arena_(arena) {
+    for (; begin != end; ++begin) {
+      EmplaceBack(*begin);
+    }
+  }
+  ChunkedVector(const ChunkedVector& other)
+      : ChunkedVector(other.arena_, other.begin(), other.end()) {}
+  ChunkedVector& operator=(const ChunkedVector& other) {
+    ChunkedVector tmp(other);
+    Swap(&tmp);
+    return *this;
+  }
+  ChunkedVector(ChunkedVector&& other) noexcept
+      : arena_(other.arena_), first_(other.first_), append_(other.append_) {
+    other.first_ = nullptr;
+    other.append_ = nullptr;
+  }
+  ChunkedVector& operator=(ChunkedVector&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+  ~ChunkedVector() { Clear(); }
+  void Swap(ChunkedVector* other) {
+    std::swap(other->arena_, arena_);
+    std::swap(other->first_, first_);
+    std::swap(other->append_, append_);
+  }
+
+  Arena* arena() const { return arena_; }
+
+  // Append a new element to the end of the vector.
+  template <typename... Args>
+  T* EmplaceBack(Args&&... args) {
+    auto* p = AppendSlot();
+    p->Init(std::forward<Args>(args)...);
+    return &**p;
+  }
+
+  // Remove the last element and return it.
+  T PopBack() {
+    GPR_ASSERT(append_ != nullptr);
+    if (append_->count == 0) {
+      GPR_ASSERT(first_ != append_);
+      Chunk* chunk = first_;
+      while (chunk->next != append_) {
+        chunk = chunk->next;
+      }
+      append_ = chunk;
+    }
+    const auto last = append_->count - 1;
+    T result = std::move(*append_->data[last]);
+    append_->data[last].Destroy();
+    append_->count = last;
+    return result;
+  }
+
+  void Clear() {
+    Chunk* chunk = first_;
+    while (chunk != nullptr && chunk->count != 0) {
+      for (size_t i = 0; i < chunk->count; i++) {
+        chunk->data[i].Destroy();
+      }
+      chunk->count = 0;
+      chunk = chunk->next;
+    }
+    append_ = first_;
+  }
+
+  // Forward-only iterator.
+  class ForwardIterator {
+   public:
+    ForwardIterator(Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
+
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using pointer = T*;
+    using reference = T&;
+
+    T& operator*() const { return *chunk_->data[n_]; }
+    T* operator->() const { return &*chunk_->data[n_]; }
+    ForwardIterator& operator++() {
+      ++n_;
+      while (chunk_ != nullptr && n_ == chunk_->count) {
+        chunk_ = chunk_->next;
+        n_ = 0;
+      }
+      return *this;
+    }
+    ForwardIterator& operator++(int) {
+      ForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
+    bool operator==(const ForwardIterator& other) const {
+      return chunk_ == other.chunk_ && n_ == other.n_;
+    }
+    bool operator!=(const ForwardIterator& other) const {
+      return !(*this == other);
+    }
+
+   private:
+    friend class ChunkedVector;
+
+    Chunk* chunk_;
+    size_t n_;
+  };
+
+  // Const Forward-only iterator.
+  class ConstForwardIterator {
+   public:
+    ConstForwardIterator(const Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
+
+    using iterator_category = std::forward_iterator_tag;
+
+    const T& operator*() const { return *chunk_->data[n_]; }
+    const T* operator->() const { return &*chunk_->data[n_]; }
+    ConstForwardIterator& operator++() {
+      ++n_;
+      while (chunk_ != nullptr && n_ == chunk_->count) {
+        chunk_ = chunk_->next;
+        n_ = 0;
+      }
+      return *this;
+    }
+    ConstForwardIterator& operator++(int) {
+      ConstForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
+    bool operator==(const ConstForwardIterator& other) const {
+      return chunk_ == other.chunk_ && n_ == other.n_;
+    }
+    bool operator!=(const ConstForwardIterator& other) const {
+      return !(*this == other);
+    }
+
+   private:
+    const Chunk* chunk_;
+    size_t n_;
+  };
+
+  ForwardIterator begin() {
+    if (first_ != nullptr && first_->count == 0) return end();
+    return ForwardIterator(first_, 0);
+  }
+  ForwardIterator end() { return ForwardIterator(nullptr, 0); }
+
+  ConstForwardIterator begin() const {
+    if (first_ != nullptr && first_->count == 0) return cend();
+    return ConstForwardIterator(first_, 0);
+  }
+  ConstForwardIterator end() const { return ConstForwardIterator(nullptr, 0); }
+
+  ConstForwardIterator cbegin() const { return begin(); }
+  ConstForwardIterator cend() const { return end(); }
+
+  // Count the number of elements in the vector.
+  size_t size() const {
+    size_t n = 0;
+    for (const Chunk* chunk = first_; chunk != nullptr; chunk = chunk->next) {
+      n += chunk->count;
+    }
+    return n;
+  }
+
+  // Return true if the vector is empty.
+  bool empty() const { return first_ == nullptr || first_->count == 0; }
+
+  void SetEnd(ForwardIterator it) {
+    if (it == end()) return;
+    Chunk* chunk = it.chunk_;
+    for (size_t i = it.n_; i < chunk->count; i++) {
+      chunk->data[i].Destroy();
+    }
+    chunk->count = it.n_;
+    append_ = chunk;
+    while ((chunk = chunk->next) != nullptr) {
+      for (size_t i = 0; i < chunk->count; i++) {
+        chunk->data[i].Destroy();
+      }
+      chunk->count = 0;
+    }
+  }
+
+ private:
+  ManualConstructor<T>* AppendSlot() {
+    if (append_ == nullptr) {
+      GPR_ASSERT(first_ == nullptr);
+      first_ = arena_->New<Chunk>();
+      append_ = first_;
+    } else if (append_->count == kChunkSize) {
+      if (append_->next == nullptr) {
+        append_->next = arena_->New<Chunk>();
+      }
+      append_ = append_->next;
+    }
+    return &append_->data[append_->count++];
+  }
+
+  Arena* arena_;
+  Chunk* first_ = nullptr;
+  Chunk* append_ = nullptr;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CHUNKED_VECTOR_H

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

@@ -15,7 +15,7 @@
 #ifndef GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
 #define GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include <utility>
 

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

@@ -0,0 +1,45 @@
+// 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_CPP_IMPL_OF_H
+#define GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H
+
+namespace grpc_core {
+
+// Declares CppType to be the backing implementation of CType.
+// Use via the curiously recursive template:
+// class Foo : public CppImplOf<Foo, grpc_foo> {};
+// Provides casting methods each way.
+// grpc_foo should be `typedef struct grpc_foo grpc_foo` and otherwise
+// not defined.
+template <typename CppType, typename CType>
+class CppImplOf {
+ public:
+  // Convert the C struct to C++
+  static CppType* FromC(CType* c_type) {
+    return reinterpret_cast<CppType*>(c_type);
+  }
+
+  // Retrieve a c pointer (of the same ownership as this)
+  CType* c_ptr() {
+    return reinterpret_cast<CType*>(static_cast<CppType*>(this));
+  }
+
+ protected:
+  ~CppImplOf() = default;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CPP_IMPL_OF_H

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

@@ -58,8 +58,8 @@ void SetGlobalConfigEnvErrorFunction(GlobalConfigEnvErrorFunctionType func) {
   g_global_config_env_error_func = func;
 }
 
-grpc_core::UniquePtr<char> GlobalConfigEnv::GetValue() {
-  return grpc_core::UniquePtr<char>(gpr_getenv(GetName()));
+UniquePtr<char> GlobalConfigEnv::GetValue() {
+  return UniquePtr<char>(gpr_getenv(GetName()));
 }
 
 void GlobalConfigEnv::SetValue(const char* value) {
@@ -80,7 +80,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvBool>::value,
               "GlobalConfigEnvBool needs to be trivially destructible.");
 
 bool GlobalConfigEnvBool::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -101,7 +101,7 @@ static_assert(std::is_trivially_destructible<GlobalConfigEnvInt32>::value,
               "GlobalConfigEnvInt32 needs to be trivially destructible.");
 
 int32_t GlobalConfigEnvInt32::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
     return default_value_;
   }
@@ -124,10 +124,10 @@ void GlobalConfigEnvInt32::Set(int32_t value) {
 static_assert(std::is_trivially_destructible<GlobalConfigEnvString>::value,
               "GlobalConfigEnvString needs to be trivially destructible.");
 
-grpc_core::UniquePtr<char> GlobalConfigEnvString::Get() {
-  grpc_core::UniquePtr<char> str = GetValue();
+UniquePtr<char> GlobalConfigEnvString::Get() {
+  UniquePtr<char> str = GetValue();
   if (str == nullptr) {
-    return grpc_core::UniquePtr<char>(gpr_strdup(default_value_));
+    return UniquePtr<char>(gpr_strdup(default_value_));
   }
   return str;
 }

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

@@ -43,7 +43,7 @@ class GlobalConfigEnv {
 
  public:
   // Returns the value of `name` variable.
-  grpc_core::UniquePtr<char> GetValue();
+  UniquePtr<char> GetValue();
 
   // Sets the value of `name` variable.
   void SetValue(const char* value);
@@ -87,7 +87,7 @@ class GlobalConfigEnvString : public GlobalConfigEnv {
   constexpr GlobalConfigEnvString(char* name, const char* default_value)
       : GlobalConfigEnv(name), default_value_(default_value) {}
 
-  grpc_core::UniquePtr<char> Get();
+  UniquePtr<char> Get();
   void Set(const char* value);
 
  private:

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

@@ -163,9 +163,8 @@ class PolymorphicManualConstructor {
   }
 
   typename std::aligned_storage<
-      grpc_core::manual_ctor_impl::max_size_of<DerivedTypes...>::value,
-      grpc_core::manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type
-      space_;
+      manual_ctor_impl::max_size_of<DerivedTypes...>::value,
+      manual_ctor_impl::max_align_of<DerivedTypes...>::value>::type space_;
 };
 
 template <typename Type>

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

@@ -46,6 +46,12 @@ class DefaultDeleteChar {
 template <typename T>
 using UniquePtr = std::unique_ptr<T, DefaultDeleteChar>;
 
+template <class T>
+T* Zalloc() {
+  static_assert(std::is_trivial<T>::value, "Type should be trivial");
+  return static_cast<T*>(gpr_zalloc(sizeof(T)));
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_MEMORY_H */

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

@@ -117,7 +117,7 @@ class InternallyRefCounted : public Orphanable {
     refs_.Ref(location, reason);
   }
 
-  grpc_core::RefCount refs_;
+  RefCount refs_;
 };
 
 }  // namespace grpc_core

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

@@ -208,7 +208,7 @@ class PolymorphicRefCount {
 };
 
 // NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to grpc_core::RefCounted for more details, and
+// RefCounted. Please refer to RefCounted for more details, and
 // when in doubt use PolymorphicRefCount.
 class NonPolymorphicRefCount {
  public:

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

@@ -40,8 +40,7 @@ class RefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  RefCountedPtr(Y* value) : value_(value) {}
+  explicit RefCountedPtr(Y* value) : value_(value) {}
 
   // Move ctors.
   RefCountedPtr(RefCountedPtr&& other) noexcept {
@@ -191,8 +190,7 @@ class WeakRefCountedPtr {
 
   // If value is non-null, we take ownership of a ref to it.
   template <typename Y>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  WeakRefCountedPtr(Y* value) {
+  explicit WeakRefCountedPtr(Y* value) {
     value_ = value;
   }
 

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

@@ -83,6 +83,8 @@ 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");
 }
@@ -131,8 +133,9 @@ void EncodeUInt32ToBytes(uint32_t v, char* buf) {
 }
 
 uint32_t DecodeUInt32FromBytes(const char* buf) {
-  return buf[0] | (uint32_t(buf[1]) << 8) | (uint32_t(buf[2]) << 16) |
-         (uint32_t(buf[3]) << 24);
+  const unsigned char* ubuf = reinterpret_cast<const unsigned char*>(buf);
+  return ubuf[0] | (uint32_t(ubuf[1]) << 8) | (uint32_t(ubuf[2]) << 16) |
+         (uint32_t(ubuf[3]) << 24);
 }
 
 std::vector<absl::Status> ParseChildren(absl::Cord children) {
@@ -158,7 +161,7 @@ std::vector<absl::Status> ParseChildren(absl::Cord children) {
 
 absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
                           const DebugLocation& location,
-                          std::initializer_list<absl::Status> children) {
+                          std::vector<absl::Status> children) {
   absl::Status s(code, msg);
   if (location.file() != nullptr) {
     StatusSetStr(&s, StatusStrProperty::kFile, location.file());
@@ -229,7 +232,10 @@ absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
   if (p.has_value()) {
     absl::optional<absl::string_view> sv = p->TryFlat();
     if (sv.has_value()) {
-      return *reinterpret_cast<const absl::Time*>(sv->data());
+      // copy the content before casting to avoid misaligned address access
+      alignas(absl::Time) char buf[sizeof(const absl::Time)];
+      memcpy(buf, sv->data(), sizeof(const absl::Time));
+      return *reinterpret_cast<const absl::Time*>(buf);
     } else {
       std::string s = std::string(*p);
       return *reinterpret_cast<const absl::Time*>(s.c_str());
@@ -330,7 +336,7 @@ std::string StatusToString(const absl::Status& status) {
 
 namespace internal {
 
-google_rpc_Status* StatusToProto(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(
@@ -378,28 +384,34 @@ absl::Status StatusFromProto(google_rpc_Status* msg) {
   return status;
 }
 
-uintptr_t StatusAllocPtr(absl::Status s) {
-  // This relies the fact that absl::Status has only one member, StatusRep*
-  // so the sizeof(absl::Status) has the same size of intptr_t and StatusRep*
-  // can be stolen using placement allocation.
-  static_assert(sizeof(intptr_t) == sizeof(absl::Status),
-                "absl::Status should be as big as intptr_t");
-  // This does two things;
-  // 1. Copies StatusRep* of absl::Status to ptr
-  // 2. Increases the counter of StatusRep if it's not inlined
-  uintptr_t ptr;
-  new (&ptr) absl::Status(s);
-  return ptr;
+uintptr_t StatusAllocHeapPtr(absl::Status s) {
+  if (s.ok()) return 0;
+  absl::Status* ptr = new absl::Status(s);
+  return reinterpret_cast<uintptr_t>(ptr);
 }
 
-void StatusFreePtr(uintptr_t ptr) {
-  // Decreases the counter of StatusRep if it's not inlined.
-  reinterpret_cast<absl::Status*>(&ptr)->~Status();
+void StatusFreeHeapPtr(uintptr_t ptr) {
+  absl::Status* s = reinterpret_cast<absl::Status*>(ptr);
+  delete s;
 }
 
-absl::Status StatusGetFromPtr(uintptr_t ptr) {
-  // Constructs Status from ptr having the address of StatusRep.
-  return *reinterpret_cast<absl::Status*>(&ptr);
+absl::Status StatusGetFromHeapPtr(uintptr_t ptr) {
+  if (ptr == 0) {
+    return absl::OkStatus();
+  } else {
+    return *reinterpret_cast<absl::Status*>(ptr);
+  }
+}
+
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr) {
+  if (ptr == 0) {
+    return absl::OkStatus();
+  } else {
+    absl::Status* s = reinterpret_cast<absl::Status*>(ptr);
+    absl::Status ret = std::move(*s);
+    delete s;
+    return ret;
+  }
 }
 
 }  // namespace internal

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

@@ -37,7 +37,6 @@ 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,
@@ -72,10 +71,11 @@ 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,
@@ -110,7 +110,7 @@ enum class StatusTimeProperty {
 /// Creates a status with given additional information
 absl::Status StatusCreate(
     absl::StatusCode code, absl::string_view msg, const DebugLocation& location,
-    std::initializer_list<absl::Status> children) GRPC_MUST_USE_RESULT;
+    std::vector<absl::Status> children) GRPC_MUST_USE_RESULT;
 
 /// Sets the int property to the status
 void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
@@ -153,28 +153,26 @@ namespace internal {
 
 /// Builds a upb message, google_rpc_Status from a status
 /// This is for internal implementation & test only
-google_rpc_Status* StatusToProto(absl::Status status,
+google_rpc_Status* StatusToProto(const absl::Status& status,
                                  upb_arena* arena) GRPC_MUST_USE_RESULT;
 
 /// Builds a status from a upb message, google_rpc_Status
 /// This is for internal implementation & test only
 absl::Status StatusFromProto(google_rpc_Status* msg) GRPC_MUST_USE_RESULT;
 
-/// The same value of grpc_core::internal::StatusAllocPtr(absl::OkStatus())
-static constexpr uintptr_t kOkStatusPtr = 0;
+/// Returns ptr that is allocated in the heap memory and the given status is
+/// copied into. This ptr can be used to get Status later and should be
+/// freed by StatusFreeHeapPtr. This can be 0 in case of OkStatus.
+uintptr_t StatusAllocHeapPtr(absl::Status s);
 
-/// Returns ptr where the given status is copied into.
-/// This ptr can be used to get Status later and should be freed by
-/// StatusFreePtr. This shouldn't be used except migration purpose.
-uintptr_t StatusAllocPtr(absl::Status s);
+/// Frees the allocated status at heap ptr.
+void StatusFreeHeapPtr(uintptr_t ptr);
 
-/// Frees the allocated status at ptr.
-/// This shouldn't be used except migration purpose.
-void StatusFreePtr(uintptr_t ptr);
+/// Get the status from a heap ptr.
+absl::Status StatusGetFromHeapPtr(uintptr_t ptr);
 
-/// Get the status from ptr.
-/// This shouldn't be used except migration purpose.
-absl::Status StatusGetFromPtr(uintptr_t ptr);
+/// Move the status from a heap ptr. (GetFrom & FreeHeap)
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr);
 
 }  // namespace internal