From 718c8341ca8dcad17d93dc9e20c289c48b7ece34 Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Wed, 28 Feb 2018 13:00:04 -0800 Subject: Retry support. --- tools/doxygen/Doxyfile.c++.internal | 1 + 1 file changed, 1 insertion(+) (limited to 'tools/doxygen/Doxyfile.c++.internal') diff --git a/tools/doxygen/Doxyfile.c++.internal b/tools/doxygen/Doxyfile.c++.internal index 7eab3f09fd..60d8975e52 100644 --- a/tools/doxygen/Doxyfile.c++.internal +++ b/tools/doxygen/Doxyfile.c++.internal @@ -1149,6 +1149,7 @@ src/core/lib/transport/pid_controller.h \ src/core/lib/transport/service_config.h \ src/core/lib/transport/static_metadata.h \ src/core/lib/transport/status_conversion.h \ +src/core/lib/transport/status_metadata.h \ src/core/lib/transport/timeout_encoding.h \ src/core/lib/transport/transport.h \ src/core/lib/transport/transport_impl.h \ -- cgit v1.2.3 From 396d49d95842b42ee2537f54a12919aff47a0401 Mon Sep 17 00:00:00 2001 From: David Garcia Quintas Date: Wed, 28 Feb 2018 16:06:30 -0800 Subject: Introduce a 'weak' and mutable version of slice hash table --- BUILD | 3 +- CMakeLists.txt | 37 ++++++++ Makefile | 48 ++++++++++ build.yaml | 13 +++ gRPC-C++.podspec | 2 + gRPC-Core.podspec | 2 + grpc.gemspec | 1 + package.xml | 1 + src/core/lib/slice/slice_weak_hash_table.h | 105 +++++++++++++++++++++ test/core/slice/BUILD | 40 +++++++- test/core/slice/slice_weak_hash_table_test.cc | 105 +++++++++++++++++++++ tools/doxygen/Doxyfile.c++.internal | 1 + tools/doxygen/Doxyfile.core.internal | 1 + tools/run_tests/generated/sources_and_headers.json | 19 ++++ tools/run_tests/generated/tests.json | 24 +++++ 15 files changed, 396 insertions(+), 6 deletions(-) create mode 100644 src/core/lib/slice/slice_weak_hash_table.h create mode 100644 test/core/slice/slice_weak_hash_table_test.cc (limited to 'tools/doxygen/Doxyfile.c++.internal') diff --git a/BUILD b/BUILD index 34225437cf..517648eccd 100644 --- a/BUILD +++ b/BUILD @@ -55,7 +55,7 @@ config_setting( config_setting( name = "windows", - values = { "cpu": "x64_windows" }, + values = {"cpu": "x64_windows"}, ) config_setting( @@ -906,6 +906,7 @@ grpc_cc_library( "src/core/lib/slice/slice_hash_table.h", "src/core/lib/slice/slice_internal.h", "src/core/lib/slice/slice_string_helpers.h", + "src/core/lib/slice/slice_weak_hash_table.h", "src/core/lib/surface/api_trace.h", "src/core/lib/surface/call.h", "src/core/lib/surface/call_test_only.h", diff --git a/CMakeLists.txt b/CMakeLists.txt index 3b0f593f30..7e4ddf41f0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -594,6 +594,7 @@ add_dependencies(buildtests_cxx server_early_return_test) add_dependencies(buildtests_cxx server_request_call_test) add_dependencies(buildtests_cxx shutdown_test) add_dependencies(buildtests_cxx slice_hash_table_test) +add_dependencies(buildtests_cxx slice_weak_hash_table_test) add_dependencies(buildtests_cxx stats_test) add_dependencies(buildtests_cxx status_test) if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX) @@ -12113,6 +12114,42 @@ target_link_libraries(slice_hash_table_test endif (gRPC_BUILD_TESTS) if (gRPC_BUILD_TESTS) +add_executable(slice_weak_hash_table_test + test/core/slice/slice_weak_hash_table_test.cc + third_party/googletest/googletest/src/gtest-all.cc + third_party/googletest/googlemock/src/gmock-all.cc +) + + +target_include_directories(slice_weak_hash_table_test + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include + PRIVATE ${_gRPC_SSL_INCLUDE_DIR} + PRIVATE ${_gRPC_PROTOBUF_INCLUDE_DIR} + PRIVATE ${_gRPC_ZLIB_INCLUDE_DIR} + PRIVATE ${_gRPC_BENCHMARK_INCLUDE_DIR} + PRIVATE ${_gRPC_CARES_INCLUDE_DIR} + PRIVATE ${_gRPC_GFLAGS_INCLUDE_DIR} + PRIVATE third_party/googletest/googletest/include + PRIVATE third_party/googletest/googletest + PRIVATE third_party/googletest/googlemock/include + PRIVATE third_party/googletest/googlemock + PRIVATE ${_gRPC_PROTO_GENS_DIR} +) + +target_link_libraries(slice_weak_hash_table_test + ${_gRPC_PROTOBUF_LIBRARIES} + ${_gRPC_ALLTARGETS_LIBRARIES} + grpc_test_util + grpc + gpr_test_util + gpr + ${_gRPC_GFLAGS_LIBRARIES} +) + +endif (gRPC_BUILD_TESTS) +if (gRPC_BUILD_TESTS) + add_executable(stats_test test/core/debug/stats_test.cc third_party/googletest/googletest/src/gtest-all.cc diff --git a/Makefile b/Makefile index 6149c2740d..f5aef69cfd 100644 --- a/Makefile +++ b/Makefile @@ -1181,6 +1181,7 @@ server_early_return_test: $(BINDIR)/$(CONFIG)/server_early_return_test server_request_call_test: $(BINDIR)/$(CONFIG)/server_request_call_test shutdown_test: $(BINDIR)/$(CONFIG)/shutdown_test slice_hash_table_test: $(BINDIR)/$(CONFIG)/slice_hash_table_test +slice_weak_hash_table_test: $(BINDIR)/$(CONFIG)/slice_weak_hash_table_test stats_test: $(BINDIR)/$(CONFIG)/stats_test status_test: $(BINDIR)/$(CONFIG)/status_test streaming_throughput_test: $(BINDIR)/$(CONFIG)/streaming_throughput_test @@ -1639,6 +1640,7 @@ buildtests_cxx: privatelibs_cxx \ $(BINDIR)/$(CONFIG)/server_request_call_test \ $(BINDIR)/$(CONFIG)/shutdown_test \ $(BINDIR)/$(CONFIG)/slice_hash_table_test \ + $(BINDIR)/$(CONFIG)/slice_weak_hash_table_test \ $(BINDIR)/$(CONFIG)/stats_test \ $(BINDIR)/$(CONFIG)/status_test \ $(BINDIR)/$(CONFIG)/streaming_throughput_test \ @@ -1784,6 +1786,7 @@ buildtests_cxx: privatelibs_cxx \ $(BINDIR)/$(CONFIG)/server_request_call_test \ $(BINDIR)/$(CONFIG)/shutdown_test \ $(BINDIR)/$(CONFIG)/slice_hash_table_test \ + $(BINDIR)/$(CONFIG)/slice_weak_hash_table_test \ $(BINDIR)/$(CONFIG)/stats_test \ $(BINDIR)/$(CONFIG)/status_test \ $(BINDIR)/$(CONFIG)/streaming_throughput_test \ @@ -2209,6 +2212,8 @@ test_cxx: buildtests_cxx $(Q) $(BINDIR)/$(CONFIG)/shutdown_test || ( echo test shutdown_test failed ; exit 1 ) $(E) "[RUN] Testing slice_hash_table_test" $(Q) $(BINDIR)/$(CONFIG)/slice_hash_table_test || ( echo test slice_hash_table_test failed ; exit 1 ) + $(E) "[RUN] Testing slice_weak_hash_table_test" + $(Q) $(BINDIR)/$(CONFIG)/slice_weak_hash_table_test || ( echo test slice_weak_hash_table_test failed ; exit 1 ) $(E) "[RUN] Testing stats_test" $(Q) $(BINDIR)/$(CONFIG)/stats_test || ( echo test stats_test failed ; exit 1 ) $(E) "[RUN] Testing status_test" @@ -17922,6 +17927,49 @@ endif endif +SLICE_WEAK_HASH_TABLE_TEST_SRC = \ + test/core/slice/slice_weak_hash_table_test.cc \ + +SLICE_WEAK_HASH_TABLE_TEST_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(SLICE_WEAK_HASH_TABLE_TEST_SRC)))) +ifeq ($(NO_SECURE),true) + +# You can't build secure targets if you don't have OpenSSL. + +$(BINDIR)/$(CONFIG)/slice_weak_hash_table_test: openssl_dep_error + +else + + + + +ifeq ($(NO_PROTOBUF),true) + +# You can't build the protoc plugins or protobuf-enabled targets if you don't have protobuf 3.0.0+. + +$(BINDIR)/$(CONFIG)/slice_weak_hash_table_test: protobuf_dep_error + +else + +$(BINDIR)/$(CONFIG)/slice_weak_hash_table_test: $(PROTOBUF_DEP) $(SLICE_WEAK_HASH_TABLE_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a + $(E) "[LD] Linking $@" + $(Q) mkdir -p `dirname $@` + $(Q) $(LDXX) $(LDFLAGS) $(SLICE_WEAK_HASH_TABLE_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/slice_weak_hash_table_test + +endif + +endif + +$(OBJDIR)/$(CONFIG)/test/core/slice/slice_weak_hash_table_test.o: $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a + +deps_slice_weak_hash_table_test: $(SLICE_WEAK_HASH_TABLE_TEST_OBJS:.o=.dep) + +ifneq ($(NO_SECURE),true) +ifneq ($(NO_DEPS),true) +-include $(SLICE_WEAK_HASH_TABLE_TEST_OBJS:.o=.dep) +endif +endif + + STATS_TEST_SRC = \ test/core/debug/stats_test.cc \ diff --git a/build.yaml b/build.yaml index 6c955676fe..13747310fd 100644 --- a/build.yaml +++ b/build.yaml @@ -403,6 +403,7 @@ filegroups: - src/core/lib/slice/slice_hash_table.h - src/core/lib/slice/slice_internal.h - src/core/lib/slice/slice_string_helpers.h + - src/core/lib/slice/slice_weak_hash_table.h - src/core/lib/surface/api_trace.h - src/core/lib/surface/call.h - src/core/lib/surface/call_test_only.h @@ -4829,6 +4830,18 @@ targets: - gpr_test_util - gpr uses_polling: false +- name: slice_weak_hash_table_test + gtest: true + build: test + language: c++ + src: + - test/core/slice/slice_weak_hash_table_test.cc + deps: + - grpc_test_util + - grpc + - gpr_test_util + - gpr + uses_polling: false - name: stats_test gtest: true build: test diff --git a/gRPC-C++.podspec b/gRPC-C++.podspec index 737af98cac..1f2266336e 100644 --- a/gRPC-C++.podspec +++ b/gRPC-C++.podspec @@ -408,6 +408,7 @@ Pod::Spec.new do |s| 'src/core/lib/slice/slice_hash_table.h', 'src/core/lib/slice/slice_internal.h', 'src/core/lib/slice/slice_string_helpers.h', + 'src/core/lib/slice/slice_weak_hash_table.h', 'src/core/lib/surface/api_trace.h', 'src/core/lib/surface/call.h', 'src/core/lib/surface/call_test_only.h', @@ -585,6 +586,7 @@ Pod::Spec.new do |s| 'src/core/lib/slice/slice_hash_table.h', 'src/core/lib/slice/slice_internal.h', 'src/core/lib/slice/slice_string_helpers.h', + 'src/core/lib/slice/slice_weak_hash_table.h', 'src/core/lib/surface/api_trace.h', 'src/core/lib/surface/call.h', 'src/core/lib/surface/call_test_only.h', diff --git a/gRPC-Core.podspec b/gRPC-Core.podspec index a7b9131423..443cf76a51 100644 --- a/gRPC-Core.podspec +++ b/gRPC-Core.podspec @@ -420,6 +420,7 @@ Pod::Spec.new do |s| 'src/core/lib/slice/slice_hash_table.h', 'src/core/lib/slice/slice_internal.h', 'src/core/lib/slice/slice_string_helpers.h', + 'src/core/lib/slice/slice_weak_hash_table.h', 'src/core/lib/surface/api_trace.h', 'src/core/lib/surface/call.h', 'src/core/lib/surface/call_test_only.h', @@ -909,6 +910,7 @@ Pod::Spec.new do |s| 'src/core/lib/slice/slice_hash_table.h', 'src/core/lib/slice/slice_internal.h', 'src/core/lib/slice/slice_string_helpers.h', + 'src/core/lib/slice/slice_weak_hash_table.h', 'src/core/lib/surface/api_trace.h', 'src/core/lib/surface/call.h', 'src/core/lib/surface/call_test_only.h', diff --git a/grpc.gemspec b/grpc.gemspec index 490aceb97e..71849842bb 100644 --- a/grpc.gemspec +++ b/grpc.gemspec @@ -346,6 +346,7 @@ Gem::Specification.new do |s| s.files += %w( src/core/lib/slice/slice_hash_table.h ) s.files += %w( src/core/lib/slice/slice_internal.h ) s.files += %w( src/core/lib/slice/slice_string_helpers.h ) + s.files += %w( src/core/lib/slice/slice_weak_hash_table.h ) s.files += %w( src/core/lib/surface/api_trace.h ) s.files += %w( src/core/lib/surface/call.h ) s.files += %w( src/core/lib/surface/call_test_only.h ) diff --git a/package.xml b/package.xml index 705b91a2cd..ef8eb6e57e 100644 --- a/package.xml +++ b/package.xml @@ -353,6 +353,7 @@ + diff --git a/src/core/lib/slice/slice_weak_hash_table.h b/src/core/lib/slice/slice_weak_hash_table.h new file mode 100644 index 0000000000..9d0ddfc2d2 --- /dev/null +++ b/src/core/lib/slice/slice_weak_hash_table.h @@ -0,0 +1,105 @@ +/* + * Copyright 2016 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_SLICE_SLICE_WEAK_HASH_TABLE_H +#define GRPC_CORE_LIB_SLICE_SLICE_WEAK_HASH_TABLE_H + +#include + +#include "src/core/lib/gprpp/memory.h" +#include "src/core/lib/gprpp/ref_counted.h" +#include "src/core/lib/gprpp/ref_counted_ptr.h" +#include "src/core/lib/slice/slice_internal.h" + +/// Weak hash table implementation. +/// +/// This entries in this table are weak: an entry may be removed at any time due +/// to a number of reasons: memory pressure, hash collisions, etc. +/// +/// The keys are \a grpc_slice objects. The values are of arbitrary type. +/// +/// This class is thread unsafe. It's the caller's responsibility to ensure +/// proper locking when accessing its methods. + +namespace grpc_core { + +template +class SliceWeakHashTable : public RefCounted> { + public: + /// Creates a new table of at most \a size entries. + static RefCountedPtr Create() { + return MakeRefCounted>(); + } + + /// Add a mapping from \a key to \a value, taking ownership of \a key. This + /// operation will always succeed. It may discard older entries. + void Add(grpc_slice key, T value) { + const size_t idx = grpc_slice_hash(key) % Size; + entries_[idx].Set(key, std::move(value)); + return; + } + + /// Returns the value from the table associated with / \a key or null if not + /// found. + const T* Get(const grpc_slice key) const { + const size_t idx = grpc_slice_hash(key) % Size; + const auto& entry = entries_[idx]; + return grpc_slice_eq(entry.key(), key) ? entry.value() : nullptr; + } + + private: + // So New() can call our private ctor. + template + friend T2* New(Args&&... args); + + SliceWeakHashTable() = default; + ~SliceWeakHashTable() = default; + + /// The type of the table "rows". + class Entry { + public: + Entry() = default; + ~Entry() { + if (is_set_) grpc_slice_unref_internal(key_); + } + grpc_slice key() const { return key_; } + + /// Return the entry's value, or null if unset. + const T* value() const { + if (!is_set_) return nullptr; + return &value_; + } + + /// Set the \a key and \a value (which is moved) for the entry. + void Set(grpc_slice key, T&& value) { + if (is_set_) grpc_slice_unref_internal(key_); + key_ = key; + value_ = std::move(value); + is_set_ = true; + } + + private: + grpc_slice key_; + T value_; + bool is_set_ = false; + }; + + Entry entries_[Size]; +}; + +} // namespace grpc_core + +#endif /* GRPC_CORE_LIB_SLICE_SLICE_WEAK_HASH_TABLE_H */ diff --git a/test/core/slice/BUILD b/test/core/slice/BUILD index 226aed1db9..9a1a506a43 100644 --- a/test/core/slice/BUILD +++ b/test/core/slice/BUILD @@ -23,8 +23,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer") grpc_fuzzer( name = "percent_encode_fuzzer", srcs = ["percent_encode_fuzzer.cc"], - language = "C++", corpus = "percent_encode_corpus", + language = "C++", deps = [ "//:gpr", "//:grpc", @@ -35,8 +35,8 @@ grpc_fuzzer( grpc_fuzzer( name = "percent_decode_fuzzer", srcs = ["percent_decode_fuzzer.cc"], - language = "C++", corpus = "percent_decode_corpus", + language = "C++", deps = [ "//:gpr", "//:grpc", @@ -59,8 +59,13 @@ grpc_cc_test( grpc_cc_test( name = "slice_test", srcs = ["slice_test.cc"], - deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"], language = "C++", + deps = [ + "//:gpr", + "//:grpc", + "//test/core/util:gpr_test_util", + "//test/core/util:grpc_test_util", + ], ) grpc_cc_test( @@ -78,18 +83,43 @@ grpc_cc_test( grpc_cc_test( name = "slice_buffer_test", srcs = ["slice_buffer_test.cc"], - deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"], language = "C++", + deps = [ + "//:gpr", + "//:grpc", + "//test/core/util:gpr_test_util", + "//test/core/util:grpc_test_util", + ], ) grpc_cc_test( name = "slice_hash_table_test", srcs = ["slice_hash_table_test.cc"], - deps = ["//:grpc", "//test/core/util:grpc_test_util", "//:gpr", "//test/core/util:gpr_test_util"], + external_deps = [ + "gtest", + ], language = "C++", + deps = [ + "//:gpr", + "//:grpc", + "//test/core/util:gpr_test_util", + "//test/core/util:grpc_test_util", + ], +) + +grpc_cc_test( + name = "slice_weak_hash_table_test", + srcs = ["slice_weak_hash_table_test.cc"], external_deps = [ "gtest", ], + language = "C++", + deps = [ + "//:gpr", + "//:grpc", + "//test/core/util:gpr_test_util", + "//test/core/util:grpc_test_util", + ], ) grpc_cc_test( diff --git a/test/core/slice/slice_weak_hash_table_test.cc b/test/core/slice/slice_weak_hash_table_test.cc new file mode 100644 index 0000000000..4711d2fd26 --- /dev/null +++ b/test/core/slice/slice_weak_hash_table_test.cc @@ -0,0 +1,105 @@ +/* + * + * Copyright 2017 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 "src/core/lib/slice/slice_weak_hash_table.h" + +#include +#include + +#include + +#include +#include +#include + +#include "src/core/lib/gpr/useful.h" +#include "src/core/lib/slice/slice_internal.h" +#include "test/core/util/test_config.h" + +namespace grpc_core { +namespace { + +grpc_slice BuildRefCountedKey(const char* key_str) { + const size_t key_length = strlen(key_str); + grpc_slice key = grpc_slice_malloc_large(key_length); + memcpy(GRPC_SLICE_START_PTR(key), key_str, key_length); + return key; +} + +TEST(SliceWeakHashTable, Basic) { + auto table = SliceWeakHashTable, 10>::Create(); + // Single key-value insertion. + grpc_slice key = BuildRefCountedKey("key"); + grpc_slice_ref(key); // Get doesn't own. + table->Add(key, UniquePtr(gpr_strdup("value"))); + ASSERT_NE(table->Get(key), nullptr); + ASSERT_STREQ(table->Get(key)->get(), "value"); + grpc_slice_unref(key); + // Unknown key. + ASSERT_EQ(table->Get(grpc_slice_from_static_string("unknown_key")), nullptr); +} + +TEST(SliceWeakHashTable, ValueTypeConstructor) { + struct Value { + Value() : a(123) {} + int a; + }; + auto table = SliceWeakHashTable::Create(); + grpc_slice key = BuildRefCountedKey("key"); + grpc_slice_ref(key); // Get doesn't own. + table->Add(key, Value()); + ASSERT_EQ(table->Get(key)->a, 123); + grpc_slice_unref(key); +} + +TEST(SliceWeakHashTable, ForceOverload) { + constexpr int kTableSize = 10; + auto table = SliceWeakHashTable, kTableSize>::Create(); + // Insert a multiple of the maximum size table. + for (int i = 0; i < kTableSize * 2; ++i) { + std::ostringstream oss; + oss << "key-" << i; + grpc_slice key = BuildRefCountedKey(oss.str().c_str()); + oss.clear(); + oss << "value-" << i; + table->Add(key, UniquePtr(gpr_strdup(oss.str().c_str()))); + } + // Verify that some will have been replaced. + int num_missing = 0; + for (int i = 0; i < kTableSize * 2; ++i) { + std::ostringstream oss; + oss << "key-" << i; + grpc_slice key = BuildRefCountedKey(oss.str().c_str()); + if (table->Get(key) == nullptr) num_missing++; + grpc_slice_unref(key); + } + // At least kTableSize elements will be missing. + ASSERT_GE(num_missing, kTableSize); +} + +} // namespace +} // namespace grpc_core + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + grpc_test_init(argc, argv); + grpc_core::ExecCtx::GlobalInit(); + int result = RUN_ALL_TESTS(); + grpc_core::ExecCtx::GlobalShutdown(); + return result; +} diff --git a/tools/doxygen/Doxyfile.c++.internal b/tools/doxygen/Doxyfile.c++.internal index 7eab3f09fd..9d0c7db051 100644 --- a/tools/doxygen/Doxyfile.c++.internal +++ b/tools/doxygen/Doxyfile.c++.internal @@ -1125,6 +1125,7 @@ src/core/lib/slice/percent_encoding.h \ src/core/lib/slice/slice_hash_table.h \ src/core/lib/slice/slice_internal.h \ src/core/lib/slice/slice_string_helpers.h \ +src/core/lib/slice/slice_weak_hash_table.h \ src/core/lib/surface/api_trace.h \ src/core/lib/surface/call.h \ src/core/lib/surface/call_test_only.h \ diff --git a/tools/doxygen/Doxyfile.core.internal b/tools/doxygen/Doxyfile.core.internal index dd1facd7b4..6021f293a6 100644 --- a/tools/doxygen/Doxyfile.core.internal +++ b/tools/doxygen/Doxyfile.core.internal @@ -1333,6 +1333,7 @@ src/core/lib/slice/slice_intern.cc \ src/core/lib/slice/slice_internal.h \ src/core/lib/slice/slice_string_helpers.cc \ src/core/lib/slice/slice_string_helpers.h \ +src/core/lib/slice/slice_weak_hash_table.h \ src/core/lib/surface/README.md \ src/core/lib/surface/api_trace.cc \ src/core/lib/surface/api_trace.h \ diff --git a/tools/run_tests/generated/sources_and_headers.json b/tools/run_tests/generated/sources_and_headers.json index 2ad0e23fed..b0fb829e71 100644 --- a/tools/run_tests/generated/sources_and_headers.json +++ b/tools/run_tests/generated/sources_and_headers.json @@ -4170,6 +4170,23 @@ "third_party": false, "type": "target" }, + { + "deps": [ + "gpr", + "gpr_test_util", + "grpc", + "grpc_test_util" + ], + "headers": [], + "is_filegroup": false, + "language": "c++", + "name": "slice_weak_hash_table_test", + "src": [ + "test/core/slice/slice_weak_hash_table_test.cc" + ], + "third_party": false, + "type": "target" + }, { "deps": [ "gpr", @@ -8731,6 +8748,7 @@ "src/core/lib/slice/slice_hash_table.h", "src/core/lib/slice/slice_internal.h", "src/core/lib/slice/slice_string_helpers.h", + "src/core/lib/slice/slice_weak_hash_table.h", "src/core/lib/surface/api_trace.h", "src/core/lib/surface/call.h", "src/core/lib/surface/call_test_only.h", @@ -8873,6 +8891,7 @@ "src/core/lib/slice/slice_hash_table.h", "src/core/lib/slice/slice_internal.h", "src/core/lib/slice/slice_string_helpers.h", + "src/core/lib/slice/slice_weak_hash_table.h", "src/core/lib/surface/api_trace.h", "src/core/lib/surface/call.h", "src/core/lib/surface/call_test_only.h", diff --git a/tools/run_tests/generated/tests.json b/tools/run_tests/generated/tests.json index 649581dada..f8cd2f2dce 100644 --- a/tools/run_tests/generated/tests.json +++ b/tools/run_tests/generated/tests.json @@ -4455,6 +4455,30 @@ ], "uses_polling": false }, + { + "args": [], + "benchmark": false, + "ci_platforms": [ + "linux", + "mac", + "posix", + "windows" + ], + "cpu_cost": 1.0, + "exclude_configs": [], + "exclude_iomgrs": [], + "flaky": false, + "gtest": true, + "language": "c++", + "name": "slice_weak_hash_table_test", + "platforms": [ + "linux", + "mac", + "posix", + "windows" + ], + "uses_polling": false + }, { "args": [], "benchmark": false, -- cgit v1.2.3