grpc 1.41.1 → 1.42.0.pre1

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

@@ -0,0 +1,211 @@
+// 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 "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/gprpp/manual_constructor.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=(ChunkedVector other) {
+    Swap(&other);
+    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) {}
+
+    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;
+    }
+    bool operator==(const ForwardIterator& other) const {
+      return chunk_ == other.chunk_ && n_ == other.n_;
+    }
+    bool operator!=(const ForwardIterator& other) const {
+      return !(*this == other);
+    }
+
+   private:
+    Chunk* chunk_;
+    size_t n_;
+  };
+
+  // Const Forward-only iterator.
+  class ConstForwardIterator {
+   public:
+    ConstForwardIterator(const Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
+
+    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;
+    }
+    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;
+  }
+
+ 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/match.h

@@ -15,7 +15,7 @@
 #ifndef GRPC_CORE_LIB_GPRPP_MATCH_H
 #define GRPC_CORE_LIB_GPRPP_MATCH_H
 
-#include <grpc/impl/codegen/port_platform.h>
+#include <grpc/support/port_platform.h>
 
 #include "absl/types/variant.h"
 

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/overload.h

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

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

@@ -131,8 +131,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) {
@@ -330,7 +331,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(
@@ -402,6 +403,25 @@ absl::Status StatusGetFromPtr(uintptr_t ptr) {
   return *reinterpret_cast<absl::Status*>(&ptr);
 }
 
+uintptr_t StatusAllocHeapPtr(absl::Status s) {
+  if (s.ok()) return kOkStatusPtr;
+  absl::Status* ptr = new absl::Status(s);
+  return reinterpret_cast<uintptr_t>(ptr);
+}
+
+void StatusFreeHeapPtr(uintptr_t ptr) {
+  absl::Status* s = reinterpret_cast<absl::Status*>(ptr);
+  delete s;
+}
+
+absl::Status StatusGetFromHeapPtr(uintptr_t ptr) {
+  if (ptr == kOkStatusPtr) {
+    return absl::OkStatus();
+  } else {
+    return *reinterpret_cast<absl::Status*>(ptr);
+  }
+}
+
 }  // namespace internal
 
 }  // namespace grpc_core

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

@@ -153,7 +153,7 @@ 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
@@ -176,6 +176,17 @@ void StatusFreePtr(uintptr_t ptr);
 /// This shouldn't be used except migration purpose.
 absl::Status StatusGetFromPtr(uintptr_t ptr);
 
+/// 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);
+
+/// Frees the allocated status at heap ptr.
+void StatusFreeHeapPtr(uintptr_t ptr);
+
+/// Get the status from a heap ptr.
+absl::Status StatusGetFromHeapPtr(uintptr_t ptr);
+
 }  // namespace internal
 
 }  // namespace grpc_core