grpc 1.47.0 → 1.53.0

data/src/core/lib/event_engine/iomgr_engine.cc

@@ -1,206 +0,0 @@
-// 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.
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/event_engine/iomgr_engine.h"
-
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "absl/cleanup/cleanup.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/strings/str_cat.h"
-#include "absl/time/clock.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/event_engine/trace.h"
-#include "src/core/lib/gprpp/match.h"
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/timer.h"
-
-namespace grpc_event_engine {
-namespace experimental {
-
-namespace {
-
-struct ClosureData {
-  grpc_timer timer;
-  grpc_closure closure;
-  absl::variant<std::function<void()>, EventEngine::Closure*> cb;
-  IomgrEventEngine* engine;
-  EventEngine::TaskHandle handle;
-};
-
-// Timer limits due to quirks in the iomgr implementation.
-// If deadline <= Now, the callback will be run inline, which can result in lock
-// issues. And absl::InfiniteFuture yields UB.
-absl::Time Clamp(absl::Time when) {
-  absl::Time max = absl::Now() + absl::Hours(8766);
-  absl::Time min = absl::Now() + absl::Milliseconds(2);
-  if (when > max) return max;
-  if (when < min) return min;
-  return when;
-}
-
-std::string HandleToString(EventEngine::TaskHandle handle) {
-  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
-}
-
-}  // namespace
-
-IomgrEventEngine::IomgrEventEngine() {}
-
-IomgrEventEngine::~IomgrEventEngine() {
-  grpc_core::MutexLock lock(&mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
-    for (auto handle : known_handles_) {
-      gpr_log(GPR_ERROR,
-              "(event_engine) IomgrEventEngine:%p uncleared TaskHandle at "
-              "shutdown:%s",
-              this, HandleToString(handle).c_str());
-    }
-  }
-  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
-}
-
-bool IomgrEventEngine::Cancel(EventEngine::TaskHandle handle) {
-  grpc_core::ExecCtx ctx;
-  grpc_core::MutexLock lock(&mu_);
-  if (!known_handles_.contains(handle)) return false;
-  auto* cd = reinterpret_cast<ClosureData*>(handle.keys[0]);
-  grpc_timer_cancel(&cd->timer);
-  known_handles_.erase(handle);
-  return true;
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                std::function<void()> closure) {
-  return RunAtInternal(when, std::move(closure));
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
-                                                EventEngine::Closure* closure) {
-  return RunAtInternal(when, closure);
-}
-
-void IomgrEventEngine::Run(std::function<void()> closure) {
-  RunInternal(closure);
-}
-
-void IomgrEventEngine::Run(EventEngine::Closure* closure) {
-  RunInternal(closure);
-}
-
-EventEngine::TaskHandle IomgrEventEngine::RunAtInternal(
-    absl::Time when,
-    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
-  when = Clamp(when);
-  grpc_core::ExecCtx ctx;
-  auto* cd = new ClosureData;
-  cd->cb = std::move(cb);
-  cd->engine = this;
-  GRPC_CLOSURE_INIT(
-      &cd->closure,
-      [](void* arg, grpc_error_handle error) {
-        auto* cd = static_cast<ClosureData*>(arg);
-        GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p executing callback:%s",
-                                cd->engine, HandleToString(cd->handle).c_str());
-        {
-          grpc_core::MutexLock lock(&cd->engine->mu_);
-          cd->engine->known_handles_.erase(cd->handle);
-        }
-        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
-        if (error == GRPC_ERROR_CANCELLED) return;
-        grpc_core::Match(
-            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
-            [](std::function<void()> fn) { fn(); });
-      },
-      cd, nullptr);
-  // kludge to deal with realtime/monotonic clock conversion
-  absl::Time absl_now = absl::Now();
-  grpc_core::Duration duration = grpc_core::Duration::Milliseconds(
-      absl::ToInt64Milliseconds(when - absl_now) + 1);
-  grpc_core::ExecCtx::Get()->InvalidateNow();
-  grpc_core::Timestamp when_internal = grpc_core::ExecCtx::Get()->Now() +
-                                       duration +
-                                       grpc_core::Duration::Milliseconds(1);
-  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
-                                 aba_token_.fetch_add(1)};
-  grpc_core::MutexLock lock(&mu_);
-  known_handles_.insert(handle);
-  cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p scheduling callback:%s", this,
-                          HandleToString(handle).c_str());
-  grpc_timer_init(&cd->timer, when_internal, &cd->closure);
-  return handle;
-}
-
-void IomgrEventEngine::RunInternal(
-    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
-  auto* cd = new ClosureData;
-  cd->cb = std::move(cb);
-  cd->engine = this;
-  GRPC_CLOSURE_INIT(
-      &cd->closure,
-      [](void* arg, grpc_error_handle /*error*/) {
-        auto* cd = static_cast<ClosureData*>(arg);
-        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
-        grpc_core::Match(
-            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
-            [](std::function<void()> fn) { fn(); });
-      },
-      cd, nullptr);
-  // TODO(hork): have the EE spawn dedicated closure thread(s)
-  grpc_core::Executor::Run(&cd->closure, GRPC_ERROR_NONE);
-}
-
-std::unique_ptr<EventEngine::DNSResolver> IomgrEventEngine::GetDNSResolver(
-    EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-bool IomgrEventEngine::IsWorkerThread() {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-bool IomgrEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-EventEngine::ConnectionHandle IomgrEventEngine::Connect(
-    OnConnectCallback /*on_connect*/, const ResolvedAddress& /*addr*/,
-    const EndpointConfig& /*args*/, MemoryAllocator /*memory_allocator*/,
-    absl::Time /*deadline*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
-IomgrEventEngine::CreateListener(
-    Listener::AcceptCallback /*on_accept*/,
-    std::function<void(absl::Status)> /*on_shutdown*/,
-    const EndpointConfig& /*config*/,
-    std::unique_ptr<MemoryAllocatorFactory> /*memory_allocator_factory*/) {
-  GPR_ASSERT(false && "unimplemented");
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

data/src/core/lib/event_engine/iomgr_engine.h

@@ -1,118 +0,0 @@
-// 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_EVENT_ENGINE_IOMGR_ENGINE_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_H
-#include <grpc/support/port_platform.h>
-
-#include <stdint.h>
-
-#include <atomic>
-#include <functional>
-#include <memory>
-
-#include "absl/base/thread_annotations.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
-#include "absl/time/time.h"
-#include "absl/types/variant.h"
-
-#include <grpc/event_engine/endpoint_config.h>
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/event_engine/memory_allocator.h>
-#include <grpc/event_engine/slice_buffer.h>
-
-#include "src/core/lib/event_engine/handle_containers.h"
-#include "src/core/lib/gprpp/sync.h"
-
-namespace grpc_event_engine {
-namespace experimental {
-
-class IomgrEventEngine final : public EventEngine {
- public:
-  class IomgrEndpoint : public EventEngine::Endpoint {
-   public:
-    ~IomgrEndpoint() override;
-    void Read(std::function<void(absl::Status)> on_read, SliceBuffer* buffer,
-              const ReadArgs* args) override;
-    void Write(std::function<void(absl::Status)> on_writable, SliceBuffer* data,
-               const WriteArgs* args) override;
-    const ResolvedAddress& GetPeerAddress() const override;
-    const ResolvedAddress& GetLocalAddress() const override;
-  };
-  class IomgrListener : public EventEngine::Listener {
-   public:
-    ~IomgrListener() override;
-    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
-    absl::Status Start() override;
-  };
-  class IomgrDNSResolver : public EventEngine::DNSResolver {
-   public:
-    ~IomgrDNSResolver() override;
-    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
-                                    absl::string_view name,
-                                    absl::string_view default_port,
-                                    absl::Time deadline) override;
-    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
-                               absl::string_view name,
-                               absl::Time deadline) override;
-    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
-                               absl::string_view name,
-                               absl::Time deadline) override;
-    bool CancelLookup(LookupTaskHandle handle) override;
-  };
-
-  IomgrEventEngine();
-  ~IomgrEventEngine() override;
-
-  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
-      Listener::AcceptCallback on_accept,
-      std::function<void(absl::Status)> on_shutdown,
-      const EndpointConfig& config,
-      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
-      override;
-
-  ConnectionHandle Connect(OnConnectCallback on_connect,
-                           const ResolvedAddress& addr,
-                           const EndpointConfig& args,
-                           MemoryAllocator memory_allocator,
-                           absl::Time deadline) override;
-
-  bool CancelConnect(ConnectionHandle handle) override;
-  bool IsWorkerThread() override;
-  std::unique_ptr<DNSResolver> GetDNSResolver(
-      const DNSResolver::ResolverOptions& options) override;
-  void Run(Closure* closure) override;
-  void Run(std::function<void()> closure) override;
-  TaskHandle RunAt(absl::Time when, Closure* closure) override;
-  TaskHandle RunAt(absl::Time when, std::function<void()> closure) override;
-  bool Cancel(TaskHandle handle) override;
-
- private:
-  EventEngine::TaskHandle RunAtInternal(
-      absl::Time when,
-      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
-
-  void RunInternal(
-      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
-
-  grpc_core::Mutex mu_;
-  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
-  std::atomic<intptr_t> aba_token_{0};
-};
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_H

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

@@ -1,40 +0,0 @@
-/*
- *
- * Copyright 2015 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_GPR_ENV_H
-#define GRPC_CORE_LIB_GPR_ENV_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stdio.h>
-
-/* Env utility functions */
-
-/* Gets the environment variable value with the specified name.
-   Returns a newly allocated string. It is the responsibility of the caller to
-   gpr_free the return value if not NULL (which means that the environment
-   variable exists). */
-char* gpr_getenv(const char* name);
-
-/* Sets the environment with the specified name to the specified value. */
-void gpr_setenv(const char* name, const char* value);
-
-/* Deletes the variable name from the environment. */
-void gpr_unsetenv(const char* name);
-
-#endif /* GRPC_CORE_LIB_GPR_ENV_H */

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

@@ -1,75 +0,0 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
-
-/* for secure_getenv. */
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <grpc/support/port_platform.h>
-
-#ifdef GPR_LINUX_ENV
-
-#include <dlfcn.h>
-#include <features.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-
-char* gpr_getenv(const char* name) {
-  char* result = nullptr;
-#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-  typedef char* (*getenv_type)(const char*);
-  static getenv_type getenv_func = nullptr;
-  /* Check to see which getenv variant is supported (go from most
-   * to least secure) */
-  if (getenv_func == nullptr) {
-    const char* names[] = {"secure_getenv", "__secure_getenv", "getenv"};
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(names); i++) {
-      getenv_func = (getenv_type)dlsym(RTLD_DEFAULT, names[i]);
-      if (getenv_func != nullptr) {
-        break;
-      }
-    }
-  }
-  result = getenv_func(name);
-#elif __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)
-  result = secure_getenv(name);
-#else
-  result = getenv(name);
-#endif
-  return result == nullptr ? result : gpr_strdup(result);
-}
-
-void gpr_setenv(const char* name, const char* value) {
-  int res = setenv(name, value, 1);
-  GPR_ASSERT(res == 0);
-}
-
-void gpr_unsetenv(const char* name) {
-  int res = unsetenv(name);
-  GPR_ASSERT(res == 0);
-}
-
-#endif /* GPR_LINUX_ENV */

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

@@ -1,46 +0,0 @@
-/*
- *
- * Copyright 2015 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 GPR_POSIX_ENV
-
-#include <stdlib.h>
-
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-
-char* gpr_getenv(const char* name) {
-  char* result = getenv(name);
-  return result == nullptr ? result : gpr_strdup(result);
-}
-
-void gpr_setenv(const char* name, const char* value) {
-  int res = setenv(name, value, 1);
-  GPR_ASSERT(res == 0);
-}
-
-void gpr_unsetenv(const char* name) {
-  int res = unsetenv(name);
-  GPR_ASSERT(res == 0);
-}
-
-#endif /* GPR_POSIX_ENV */

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

@@ -1,74 +0,0 @@
-/*
- *
- * Copyright 2015 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 GPR_WINDOWS_ENV
-
-#include <windows.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/string_windows.h"
-
-char* gpr_getenv(const char* name) {
-  char* result = NULL;
-  DWORD size;
-  LPTSTR tresult = NULL;
-  LPTSTR tname = gpr_char_to_tchar(name);
-  DWORD ret;
-
-  ret = GetEnvironmentVariable(tname, NULL, 0);
-  if (ret == 0) {
-    gpr_free(tname);
-    return NULL;
-  }
-  size = ret * (DWORD)sizeof(TCHAR);
-  tresult = (LPTSTR)gpr_malloc(size);
-  ret = GetEnvironmentVariable(tname, tresult, size);
-  gpr_free(tname);
-  if (ret == 0) {
-    gpr_free(tresult);
-    return NULL;
-  }
-  result = gpr_tchar_to_char(tresult);
-  gpr_free(tresult);
-  return result;
-}
-
-void gpr_setenv(const char* name, const char* value) {
-  LPTSTR tname = gpr_char_to_tchar(name);
-  LPTSTR tvalue = gpr_char_to_tchar(value);
-  BOOL res = SetEnvironmentVariable(tname, tvalue);
-  gpr_free(tname);
-  gpr_free(tvalue);
-  GPR_ASSERT(res);
-}
-
-void gpr_unsetenv(const char* name) {
-  LPTSTR tname = gpr_char_to_tchar(name);
-  BOOL res = SetEnvironmentVariable(tname, NULL);
-  gpr_free(tname);
-  GPR_ASSERT(res);
-}
-
-#endif /* GPR_WINDOWS_ENV */

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

@@ -1,82 +0,0 @@
-/*
- *
- * Copyright 2015 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/gpr/murmur_hash.h"
-
-#include <string.h>
-
-#include "absl/base/attributes.h"
-
-#define ROTL32(x, r) (((x) << (r)) | ((x) >> (32 - (r))))
-
-#define FMIX32(h)    \
-  (h) ^= (h) >> 16;  \
-  (h) *= 0x85ebca6b; \
-  (h) ^= (h) >> 13;  \
-  (h) *= 0xc2b2ae35; \
-  (h) ^= (h) >> 16;
-
-uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed) {
-  uint32_t h1 = seed;
-  uint32_t k1;
-
-  const uint32_t c1 = 0xcc9e2d51;
-  const uint32_t c2 = 0x1b873593;
-
-  const uint8_t* keyptr = static_cast<const uint8_t*>(key);
-  const size_t bsize = sizeof(k1);
-  const size_t nblocks = len / bsize;
-
-  /* body */
-  for (size_t i = 0; i < nblocks; i++, keyptr += bsize) {
-    memcpy(&k1, keyptr, bsize);
-
-    k1 *= c1;
-    k1 = ROTL32(k1, 15);
-    k1 *= c2;
-
-    h1 ^= k1;
-    h1 = ROTL32(h1, 13);
-    h1 = h1 * 5 + 0xe6546b64;
-  }
-
-  k1 = 0;
-
-  /* tail */
-  switch (len & 3) {
-    case 3:
-      k1 ^= (static_cast<uint32_t>(keyptr[2])) << 16;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 2:
-      k1 ^= (static_cast<uint32_t>(keyptr[1])) << 8;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      k1 ^= keyptr[0];
-      k1 *= c1;
-      k1 = ROTL32(k1, 15);
-      k1 *= c2;
-      h1 ^= k1;
-  };
-
-  /* finalization */
-  h1 ^= static_cast<uint32_t>(len);
-  FMIX32(h1);
-  return h1;
-}

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

@@ -1,29 +0,0 @@
-/*
- *
- * Copyright 2015 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_GPR_MURMUR_HASH_H
-#define GRPC_CORE_LIB_GPR_MURMUR_HASH_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-
-/* compute the hash of key (length len) */
-uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed);
-
-#endif /* GRPC_CORE_LIB_GPR_MURMUR_HASH_H */