grpc 1.45.0 → 1.53.0

data/src/core/lib/iomgr/event_engine/tcp.cc

@@ -1,296 +0,0 @@
-// Copyright 2021 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.
-#include <grpc/support/port_platform.h>
-
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/event_engine/sockaddr.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/iomgr/event_engine/closure.h"
-#include "src/core/lib/iomgr/event_engine/endpoint.h"
-#include "src/core/lib/iomgr/event_engine/pollset.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/error_utils.h"
-
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
-namespace {
-using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-using ::grpc_event_engine::experimental::GrpcClosureToStatusCallback;
-using ::grpc_event_engine::experimental::SliceAllocator;
-using ::grpc_event_engine::experimental::SliceAllocatorFactory;
-using ::grpc_event_engine::experimental::SliceBuffer;
-}  // namespace
-
-class WrappedInternalSliceAllocator : public SliceAllocator {
- public:
-  explicit WrappedInternalSliceAllocator(grpc_slice_allocator* slice_allocator)
-      : slice_allocator_(slice_allocator) {}
-
-  ~WrappedInternalSliceAllocator() {
-    grpc_slice_allocator_destroy(slice_allocator_);
-  }
-
-  absl::Status Allocate(size_t size, SliceBuffer* dest,
-                        SliceAllocator::AllocateCallback cb) override {
-    // TODO(nnoble): requires the SliceBuffer definition.
-    grpc_slice_allocator_allocate(
-        slice_allocator_, size, 1, grpc_slice_allocator_intent::kReadBuffer,
-        dest->RawSliceBuffer(),
-        [](void* arg, grpc_error_handle error) {
-          auto cb = static_cast<SliceAllocator::AllocateCallback*>(arg);
-          (*cb)(grpc_error_to_absl_status(error));
-          delete cb;
-        },
-        new SliceAllocator::AllocateCallback(cb));
-    return absl::OkStatus();
-  }
-
- private:
-  grpc_slice_allocator* slice_allocator_;
-};
-
-class WrappedInternalSliceAllocatorFactory : public SliceAllocatorFactory {
- public:
-  explicit WrappedInternalSliceAllocatorFactory(
-      grpc_slice_allocator_factory* slice_allocator_factory)
-      : slice_allocator_factory_(slice_allocator_factory) {}
-
-  ~WrappedInternalSliceAllocatorFactory() {
-    grpc_slice_allocator_factory_destroy(slice_allocator_factory_);
-  }
-
-  std::unique_ptr<SliceAllocator> CreateSliceAllocator(
-      absl::string_view peer_name) override {
-    return absl::make_unique<WrappedInternalSliceAllocator>(
-        grpc_slice_allocator_factory_create_slice_allocator(
-            slice_allocator_factory_, peer_name));
-  };
-
- private:
-  grpc_slice_allocator_factory* slice_allocator_factory_;
-};
-
-struct grpc_tcp_server {
-  explicit grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener)
-      : refcount(1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr),
-        listener(std::move(listener)) {
-    shutdown_starting.head = nullptr;
-    shutdown_starting.tail = nullptr;
-  };
-  ~grpc_tcp_server() {
-    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &shutdown_starting);
-    grpc_core::ExecCtx::Get()->Flush();
-  }
-  grpc_core::RefCount refcount;
-  grpc_core::Mutex mu;
-  std::unique_ptr<EventEngine::Listener> listener;
-  grpc_closure_list shutdown_starting ABSL_GUARDED_BY(mu);
-  grpc_tcp_server_cb on_accept_internal;
-  void* on_accept_internal_arg;
-};
-
-namespace {
-
-/// Converts a grpc_closure to an EventEngine Callback. The closure is expected
-/// to already be initialized.
-EventEngine::OnConnectCallback GrpcClosureToOnConnectCallback(
-    grpc_closure* closure, grpc_endpoint** endpoint_ptr) {
-  return [closure, endpoint_ptr](
-             absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) {
-    grpc_core::ExecCtx exec_ctx;
-    if (endpoint.ok()) {
-      auto* grpc_endpoint_out =
-          reinterpret_cast<grpc_event_engine_endpoint*>(*endpoint_ptr);
-      grpc_endpoint_out->endpoint = std::move(*endpoint);
-    } else {
-      grpc_endpoint_destroy(*endpoint_ptr);
-      *endpoint_ptr = nullptr;
-    }
-    grpc_core::Closure::Run(DEBUG_LOCATION, closure,
-                            absl_status_to_grpc_error(endpoint.status()));
-    exec_ctx.Flush();
-    grpc_pollset_ee_broadcast_event();
-  };
-}
-
-/// Usage note: this method does not take ownership of any pointer arguments.
-void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                 grpc_slice_allocator* slice_allocator,
-                 grpc_pollset_set* /* interested_parties */,
-                 const grpc_channel_args* channel_args,
-                 const grpc_resolved_address* addr,
-                 grpc_core::Timestamp deadline) {
-  grpc_event_engine_endpoint* ee_endpoint =
-      reinterpret_cast<grpc_event_engine_endpoint*>(
-          grpc_tcp_create(channel_args, grpc_sockaddr_to_uri(addr)));
-  *endpoint = &ee_endpoint->base;
-  EventEngine::OnConnectCallback ee_on_connect =
-      GrpcClosureToOnConnectCallback(on_connect, endpoint);
-  auto ee_slice_allocator =
-      absl::make_unique<WrappedInternalSliceAllocator>(slice_allocator);
-  EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
-                                  addr->len);
-  absl::Time ee_deadline =
-      grpc_core::ToAbslTime(deadline.as_timespec(GPR_CLOCK_MONOTONIC));
-  ChannelArgsEndpointConfig endpoint_config(channel_args);
-  absl::Status connected = GetDefaultEventEngine()->Connect(
-      ee_on_connect, ra, endpoint_config, std::move(ee_slice_allocator),
-      ee_deadline);
-  if (!connected.ok()) {
-    // EventEngine failed to start an asynchronous connect.
-    grpc_endpoint_destroy(*endpoint);
-    *endpoint = nullptr;
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
-                            absl_status_to_grpc_error(connected));
-  }
-}
-
-grpc_error_handle tcp_server_create(
-    grpc_closure* shutdown_complete, const grpc_channel_args* args,
-    grpc_slice_allocator_factory* slice_allocator_factory,
-    grpc_tcp_server** server) {
-  ChannelArgsEndpointConfig endpoint_config(args);
-  auto ee_slice_allocator_factory =
-      absl::make_unique<WrappedInternalSliceAllocatorFactory>(
-          slice_allocator_factory);
-  EventEngine* event_engine = GetDefaultEventEngine();
-  absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
-      event_engine->CreateListener(
-          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint,
-                   const SliceAllocator& /*slice_allocator*/) {
-            grpc_core::ExecCtx exec_ctx;
-            GPR_ASSERT((*server)->on_accept_internal != nullptr);
-            grpc_event_engine_endpoint* iomgr_endpoint =
-                grpc_tcp_server_endpoint_create(std::move(ee_endpoint));
-            grpc_tcp_server_acceptor* acceptor =
-                static_cast<grpc_tcp_server_acceptor*>(
-                    gpr_zalloc(sizeof(*acceptor)));
-            acceptor->from_server = *server;
-            acceptor->external_connection = false;
-            (*server)->on_accept_internal((*server)->on_accept_internal_arg,
-                                          &iomgr_endpoint->base, nullptr,
-                                          acceptor);
-            exec_ctx.Flush();
-            grpc_pollset_ee_broadcast_event();
-          },
-          GrpcClosureToStatusCallback(shutdown_complete), endpoint_config,
-          std::move(ee_slice_allocator_factory));
-  if (!listener.ok()) {
-    return absl_status_to_grpc_error(listener.status());
-  }
-  *server = new grpc_tcp_server(std::move(*listener));
-  return GRPC_ERROR_NONE;
-}
-
-void tcp_server_start(grpc_tcp_server* server,
-                      const std::vector<grpc_pollset*>* /* pollsets */,
-                      grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
-  server->on_accept_internal = on_accept_cb;
-  server->on_accept_internal_arg = cb_arg;
-  // The iomgr API does not handle situations where the server cannot start, so
-  // a crash may be preferable for now.
-  GPR_ASSERT(server->listener->Start().ok());
-}
-
-grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
-                                      const grpc_resolved_address* addr,
-                                      int* out_port) {
-  EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
-                                  addr->len);
-  auto port = s->listener->Bind(ra);
-  if (!port.ok()) {
-    return absl_status_to_grpc_error(port.status());
-  }
-  *out_port = *port;
-  return GRPC_ERROR_NONE;
-}
-
-grpc_core::TcpServerFdHandler* tcp_server_create_fd_handler(
-    grpc_tcp_server* /* s */) {
-  // EventEngine-iomgr does not support fds.
-  return nullptr;
-}
-
-unsigned tcp_server_port_fd_count(grpc_tcp_server* /* s */,
-                                  unsigned /* port_index */) {
-  return 0;
-}
-
-int tcp_server_port_fd(grpc_tcp_server* /* s */, unsigned /* port_index */,
-                       unsigned /* fd_index */) {
-  // Note: only used internally
-  return -1;
-}
-
-grpc_tcp_server* tcp_server_ref(grpc_tcp_server* s) {
-  s->refcount.Ref(DEBUG_LOCATION, "server ref");
-  return s;
-}
-
-void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
-                                      grpc_closure* shutdown_starting) {
-  grpc_core::MutexLock lock(&s->mu);
-  grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
-                           GRPC_ERROR_NONE);
-}
-
-void tcp_server_unref(grpc_tcp_server* s) {
-  if (GPR_UNLIKELY(s->refcount.Unref(DEBUG_LOCATION, "server unref"))) {
-    delete s;
-  }
-}
-
-// No-op, all are handled on listener unref
-void tcp_server_shutdown_listeners(grpc_tcp_server* /* s */) {}
-
-}  // namespace
-
-grpc_tcp_client_vtable grpc_event_engine_tcp_client_vtable = {tcp_connect};
-grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable = {
-    tcp_server_create,        tcp_server_start,
-    tcp_server_add_port,      tcp_server_create_fd_handler,
-    tcp_server_port_fd_count, tcp_server_port_fd,
-    tcp_server_ref,           tcp_server_shutdown_starting_add,
-    tcp_server_unref,         tcp_server_shutdown_listeners};
-
-// Methods that are expected to exist elsewhere in the codebase.
-
-struct grpc_fd {
-  int fd;
-};
-
-grpc_fd* grpc_fd_create(int /* fd */, const char* /* name */,
-                        bool /* track_err */) {
-  return nullptr;
-}
-
-grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* /* fd */, const grpc_channel_args* /* channel_args */,
-    absl::string_view /* addr_str */,
-    grpc_slice_allocator* slice_allocator /* slice_allocator */) {
-  grpc_slice_allocator_destroy(slice_allocator);
-  return nullptr;
-}
-
-#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/timer.cc

@@ -1,62 +0,0 @@
-// Copyright 2021 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.
-#include <grpc/support/port_platform.h>
-
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/event_engine/closure.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/error_utils.h"
-
-namespace {
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-using ::grpc_event_engine::experimental::GrpcClosureToCallback;
-
-void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
-                grpc_closure* closure) {
-  timer->ee_task_handle = GetDefaultEventEngine()->RunAt(
-      grpc_core::ToAbslTime(deadline.as_timespec(GPR_CLOCK_REALTIME)),
-      GrpcClosureToCallback(closure));
-  timer->closure = closure;
-}
-
-void timer_cancel(grpc_timer* timer) {
-  auto handle = timer->ee_task_handle;
-  if (!GetDefaultEventEngine()->Cancel(handle)) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure,
-                            GRPC_ERROR_CANCELLED);
-  }
-}
-
-/* Internal API */
-grpc_timer_check_result timer_check(grpc_core::Timestamp* /* next */) {
-  return GRPC_TIMERS_NOT_CHECKED;
-}
-void timer_list_init() {}
-void timer_list_shutdown(void) {}
-void timer_consume_kick(void) {}
-
-}  // namespace
-
-grpc_timer_vtable grpc_event_engine_timer_vtable = {
-    timer_init,      timer_cancel,        timer_check,
-    timer_list_init, timer_list_shutdown, timer_consume_kick};
-
-#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/executor/mpmcqueue.cc

@@ -1,182 +0,0 @@
-/*
- *
- * Copyright 2019 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/iomgr/executor/mpmcqueue.h"
-
-namespace grpc_core {
-
-DebugOnlyTraceFlag grpc_thread_pool_trace(false, "thread_pool");
-
-inline void* InfLenFIFOQueue::PopFront() {
-  // Caller should already check queue is not empty and has already held the
-  // mutex. This function will assume that there is at least one element in the
-  // queue (i.e. queue_head_->content is valid).
-  void* result = queue_head_->content;
-  count_.store(count_.load(std::memory_order_relaxed) - 1,
-               std::memory_order_relaxed);
-
-  // Updates Stats when trace flag turned on.
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
-    gpr_timespec wait_time =
-        gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), queue_head_->insert_time);
-    stats_.num_completed++;
-    stats_.total_queue_time = gpr_time_add(stats_.total_queue_time, wait_time);
-    stats_.max_queue_time = gpr_time_max(
-        gpr_convert_clock_type(stats_.max_queue_time, GPR_TIMESPAN), wait_time);
-
-    if (count_.load(std::memory_order_relaxed) == 0) {
-      stats_.busy_queue_time =
-          gpr_time_add(stats_.busy_queue_time,
-                       gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), busy_time));
-    }
-
-    gpr_log(GPR_INFO,
-            "[InfLenFIFOQueue PopFront] num_completed:        %" PRIu64
-            " total_queue_time: %f max_queue_time:   %f busy_queue_time:   %f",
-            stats_.num_completed,
-            gpr_timespec_to_micros(stats_.total_queue_time),
-            gpr_timespec_to_micros(stats_.max_queue_time),
-            gpr_timespec_to_micros(stats_.busy_queue_time));
-  }
-
-  queue_head_ = queue_head_->next;
-  // Signal waiting thread
-  if (count_.load(std::memory_order_relaxed) > 0) {
-    TopWaiter()->cv.Signal();
-  }
-
-  return result;
-}
-
-InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
-  num_nodes_ = num_nodes_ + num;
-  Node* new_chunk = new Node[num];
-  new_chunk[0].next = &new_chunk[1];
-  new_chunk[num - 1].prev = &new_chunk[num - 2];
-  for (int i = 1; i < num - 1; ++i) {
-    new_chunk[i].prev = &new_chunk[i - 1];
-    new_chunk[i].next = &new_chunk[i + 1];
-  }
-  return new_chunk;
-}
-
-InfLenFIFOQueue::InfLenFIFOQueue() {
-  delete_list_size_ = kDeleteListInitSize;
-  delete_list_ = new Node*[delete_list_size_];
-
-  Node* new_chunk = AllocateNodes(kQueueInitNumNodes);
-  delete_list_[delete_list_count_++] = new_chunk;
-  queue_head_ = queue_tail_ = new_chunk;
-  new_chunk[0].prev = &new_chunk[kQueueInitNumNodes - 1];
-  new_chunk[kQueueInitNumNodes - 1].next = &new_chunk[0];
-
-  waiters_.next = &waiters_;
-  waiters_.prev = &waiters_;
-}
-
-InfLenFIFOQueue::~InfLenFIFOQueue() {
-  GPR_ASSERT(count_.load(std::memory_order_relaxed) == 0);
-  for (size_t i = 0; i < delete_list_count_; ++i) {
-    delete[] delete_list_[i];
-  }
-  delete[] delete_list_;
-}
-
-void InfLenFIFOQueue::Put(void* elem) {
-  MutexLock l(&mu_);
-
-  int curr_count = count_.load(std::memory_order_relaxed);
-
-  if (queue_tail_ == queue_head_ && curr_count != 0) {
-    // List is full. Expands list to double size by inserting new chunk of nodes
-    Node* new_chunk = AllocateNodes(curr_count);
-    delete_list_[delete_list_count_++] = new_chunk;
-    // Expands delete list on full.
-    if (delete_list_count_ == delete_list_size_) {
-      delete_list_size_ = delete_list_size_ * 2;
-      delete_list_ = new Node*[delete_list_size_];
-    }
-    new_chunk[0].prev = queue_tail_->prev;
-    new_chunk[curr_count - 1].next = queue_head_;
-    queue_tail_->prev->next = new_chunk;
-    queue_head_->prev = &new_chunk[curr_count - 1];
-    queue_tail_ = new_chunk;
-  }
-  queue_tail_->content = static_cast<void*>(elem);
-
-  // Updates Stats info
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
-    stats_.num_started++;
-    gpr_log(GPR_INFO, "[InfLenFIFOQueue Put] num_started:        %" PRIu64,
-            stats_.num_started);
-    auto current_time = gpr_now(GPR_CLOCK_MONOTONIC);
-    if (curr_count == 0) {
-      busy_time = current_time;
-    }
-    queue_tail_->insert_time = current_time;
-  }
-
-  count_.store(curr_count + 1, std::memory_order_relaxed);
-  queue_tail_ = queue_tail_->next;
-
-  TopWaiter()->cv.Signal();
-}
-
-void* InfLenFIFOQueue::Get(gpr_timespec* wait_time) {
-  MutexLock l(&mu_);
-
-  if (count_.load(std::memory_order_relaxed) == 0) {
-    gpr_timespec start_time;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
-        wait_time != nullptr) {
-      start_time = gpr_now(GPR_CLOCK_MONOTONIC);
-    }
-
-    Waiter self;
-    PushWaiter(&self);
-    do {
-      self.cv.Wait(&mu_);
-    } while (count_.load(std::memory_order_relaxed) == 0);
-    RemoveWaiter(&self);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
-        wait_time != nullptr) {
-      *wait_time = gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), start_time);
-    }
-  }
-  GPR_DEBUG_ASSERT(count_.load(std::memory_order_relaxed) > 0);
-  return PopFront();
-}
-
-void InfLenFIFOQueue::PushWaiter(Waiter* waiter) {
-  waiter->next = waiters_.next;
-  waiter->prev = &waiters_;
-  waiter->next->prev = waiter;
-  waiter->prev->next = waiter;
-}
-
-void InfLenFIFOQueue::RemoveWaiter(Waiter* waiter) {
-  GPR_DEBUG_ASSERT(waiter != &waiters_);
-  waiter->next->prev = waiter->prev;
-  waiter->prev->next = waiter->next;
-}
-
-InfLenFIFOQueue::Waiter* InfLenFIFOQueue::TopWaiter() { return waiters_.next; }
-
-}  // namespace grpc_core