cds: add a benchmark

test/common/upstream/BUILD

@@ -146,6 +146,44 @@ envoy_benchmark_test(
     benchmark_binary = "eds_speed_test",
 )
 
+envoy_cc_benchmark_binary(
+    name = "cds_speed_test",
+    srcs = ["cds_speed_test.cc"],
+    external_deps = [
+        "benchmark",
+    ],
+    deps = [
+        ":utility_lib",
+        "//source/common/config:grpc_mux_lib",
+        "//source/common/config:grpc_subscription_lib",
+        "//source/common/config:protobuf_link_hacks",
+        "//source/common/config:utility_lib",
+        "//source/common/upstream:cds_api_lib",
+        "//source/common/upstream:eds_lib",
+        "//source/extensions/transport_sockets/raw_buffer:config",
+        "//source/server:transport_socket_config_lib",
+        "//test/config:utility_lib",
+        "//test/mocks/local_info:local_info_mocks",
+        "//test/mocks/protobuf:protobuf_mocks",
+        "//test/mocks/runtime:runtime_mocks",
+        "//test/mocks/server:admin_mocks",
+        "//test/mocks/server:instance_mocks",
+        "//test/mocks/ssl:ssl_mocks",
+        "//test/mocks/upstream:cluster_manager_mocks",
+        "//test/test_common:test_runtime_lib",
+        "//test/test_common:utility_lib",
+        "@envoy_api//envoy/config/cluster/v3:pkg_cc_proto",
+        "@envoy_api//envoy/config/core/v3:pkg_cc_proto",
+        "@envoy_api//envoy/config/endpoint/v3:pkg_cc_proto",
+        "@envoy_api//envoy/service/discovery/v3:pkg_cc_proto",
+    ],
+)
+
+envoy_benchmark_test(
+    name = "cds_speed_test_benchmark_test",
+    benchmark_binary = "cds_speed_test",
+)
+
 envoy_cc_test_library(
     name = "health_check_fuzz_utils_lib",
     srcs = [

test/common/upstream/cds_speed_test.cc

@@ -0,0 +1,187 @@
+// Note: this should be run with --compilation_mode=opt, and would benefit from a
+// quiescent system with disabled cstate power management.
+
+#include "envoy/config/cluster/v3/cluster.pb.h"
+#include "envoy/config/cluster/v3/cluster.pb.validate.h"
+#include "envoy/config/core/v3/health_check.pb.h"
+#include "envoy/config/endpoint/v3/endpoint.pb.h"
+#include "envoy/config/endpoint/v3/endpoint_components.pb.h"
+#include "envoy/service/discovery/v3/discovery.pb.h"
+#include "envoy/stats/scope.h"
+
+#include "common/config/grpc_mux_impl.h"
+#include "common/config/grpc_subscription_impl.h"
+#include "common/config/utility.h"
+#include "common/singleton/manager_impl.h"
+#include "common/upstream/eds.h"
+#include "common/upstream/static_cluster.h"
+
+#include "server/transport_socket_config_impl.h"
+
+#include "test/benchmark/main.h"
+#include "test/common/upstream/utility.h"
+#include "test/config/utility.h"
+#include "test/mocks/local_info/mocks.h"
+#include "test/mocks/protobuf/mocks.h"
+#include "test/mocks/runtime/mocks.h"
+#include "test/mocks/server/admin.h"
+#include "test/mocks/server/instance.h"
+#include "test/mocks/ssl/mocks.h"
+#include "test/mocks/upstream/cluster_manager.h"
+#include "test/test_common/test_runtime.h"
+#include "test/test_common/utility.h"
+
+#include "benchmark/benchmark.h"
+
+using ::benchmark::State;
+using Envoy::benchmark::skipExpensiveBenchmarks;
+
+namespace Envoy {
+namespace Upstream {
+
+class CdsSpeedTest {
+public:
+  CdsSpeedTest(State& state, bool v2_config)
+      : state_(state), v2_config_(v2_config),
+        type_url_(v2_config_ ? "type.googleapis.com/envoy.api.v2.Cluster"
+                             : "type.googleapis.com/envoy.config.cluster.v3.Cluster"),
+        subscription_stats_(Config::Utility::generateStats(stats_)),
+        api_(Api::createApiForTest(stats_)), async_client_(new Grpc::MockAsyncClient()),
+        grpc_mux_(new Config::GrpcMuxImpl(
+            local_info_, std::unique_ptr<Grpc::MockAsyncClient>(async_client_), dispatcher_,
+            *Protobuf::DescriptorPool::generated_pool()->FindMethodByName(
+                "envoy.service.cluster.v3.ClusterDiscoveryService.StreamClusters"),
+            envoy::config::core::v3::ApiVersion::AUTO, random_, stats_, {}, true)) {
+
+    resetCluster();
+
+    cluster_->initialize([this] { initialized_ = true; });
+    EXPECT_CALL(*async_client_, startRaw(_, _, _, _)).WillOnce(testing::Return(&async_stream_));
+    subscription_->start({"fare"});
+  }
+
+  void resetCluster() {
+    local_info_.node_.mutable_locality()->set_zone("us-east-1a");
+    static_cluster_ = ConfigHelper::buildStaticCluster("cluster", 1024, "127.0.0.1");
+    Envoy::Stats::ScopePtr scope = stats_.createScope(fmt::format(
+        "cluster.{}.", static_cluster_.alt_stat_name().empty() ? static_cluster_.name()
+                                                               : static_cluster_.alt_stat_name()));
+    Envoy::Server::Configuration::TransportSocketFactoryContextImpl factory_context(
+        admin_, ssl_context_manager_, *scope, cm_, local_info_, dispatcher_, stats_,
+        singleton_manager_, tls_, validation_visitor_, *api_);
+    cluster_ = std::make_shared<StaticClusterImpl>(static_cluster_, runtime_, factory_context,
+                                                   std::move(scope), false);
+    EXPECT_EQ(Envoy::Upstream::Cluster::InitializePhase::Primary, cluster_->initializePhase());
+    callbacks_ = cm_.subscription_factory_.callbacks_;
+    subscription_ = std::make_unique<Config::GrpcSubscriptionImpl>(
+        grpc_mux_, *callbacks_, resource_decoder_, subscription_stats_, type_url_, dispatcher_,
+        std::chrono::milliseconds(), false);
+  }
+
+  void clusterHelper(bool ignore_unknown_dynamic_fields, size_t num_clusters) {
+    auto response = std::make_unique<envoy::service::discovery::v3::DiscoveryResponse>();
+    response->set_type_url(type_url_);
+    response->set_version_info(fmt::format("version-{}", version_++));
+
+    // make a pile of static clusters and add them to the response
+    for (size_t i = 0; i < num_clusters; ++i) {
+      envoy::config::cluster::v3::Cluster cluster = ConfigHelper::buildStaticCluster(
+          "cluster_" + std::to_string(i), i % 60000, "10.0.1." + std::to_string(i / 60000));
+
+      auto* resource = response->mutable_resources()->Add();
+      resource->PackFrom(cluster);
+      if (v2_config_) {
+        RELEASE_ASSERT(
+            resource->type_url() == "type.googleapis.com/envoy.config.cluster.v3.Cluster", "");
+        resource->set_type_url("type.googleapis.com/envoy.api.v2.Cluster");
+      }
+    }
+
+    validation_visitor_.setSkipValidation(ignore_unknown_dynamic_fields);
+
+    state_.SetComplexityN(num_clusters);
+    state_.ResumeTiming();
+    grpc_mux_->grpcStreamForTest().onReceiveMessage(std::move(response));
+    state_.PauseTiming();
+  }
+
+  TestDeprecatedV2Api _deprecated_v2_api_;
+  State& state_;
+  const bool v2_config_;
+  const std::string type_url_;
+  uint64_t version_{};
+  bool initialized_{};
+  Stats::IsolatedStoreImpl stats_;
+  Config::SubscriptionStats subscription_stats_;
+  Ssl::MockContextManager ssl_context_manager_;
+  envoy::config::cluster::v3::Cluster static_cluster_;
+  NiceMock<MockClusterManager> cm_;
+  NiceMock<Event::MockDispatcher> dispatcher_;
+  ClusterImplBaseSharedPtr cluster_;
+  Config::SubscriptionCallbacks* callbacks_{};
+  Config::OpaqueResourceDecoderImpl<envoy::config::cluster::v3::Cluster> resource_decoder_{
+      validation_visitor_, "name"};
+  NiceMock<Random::MockRandomGenerator> random_;
+  NiceMock<Runtime::MockLoader> runtime_;
+  NiceMock<LocalInfo::MockLocalInfo> local_info_;
+  NiceMock<Server::MockAdmin> admin_;
+  Singleton::ManagerImpl singleton_manager_{Thread::threadFactoryForTest()};
+  NiceMock<ThreadLocal::MockInstance> tls_;
+  ProtobufMessage::MockValidationVisitor validation_visitor_;
+  Api::ApiPtr api_;
+  Grpc::MockAsyncClient* async_client_;
+  NiceMock<Grpc::MockAsyncStream> async_stream_;
+  Config::GrpcMuxImplSharedPtr grpc_mux_;
+  Config::GrpcSubscriptionImplPtr subscription_;
+};
+
+} // namespace Upstream
+} // namespace Envoy
+
+static void addV3Clusters(State& state) {
+  Envoy::Upstream::CdsSpeedTest speed_test(state, false);
+  // if we've been instructed to skip tests, only run once no matter the argument:
+  const uint32_t num_clusters = skipExpensiveBenchmarks() ? 1 : state.range(1);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    // timing is resumed within the helper:
+    state.PauseTiming();
+    speed_test.clusterHelper(state.range(0), num_clusters);
+    state.ResumeTiming();
+  }
+}
+
+BENCHMARK(addV3Clusters)
+    ->Ranges({{false, true}, {64, 100000}})
+    ->Unit(benchmark::kMillisecond)
+    ->Complexity();
+
+static void addV2Clusters(State& state) {
+  // this true is the only difference from addV3clusters above
+  Envoy::Upstream::CdsSpeedTest speed_test(state, true);
+  const uint32_t num_clusters = skipExpensiveBenchmarks() ? 1 : state.range(1);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    state.PauseTiming();
+    speed_test.clusterHelper(state.range(0), num_clusters);
+    state.ResumeTiming();
+  }
+}
+
+BENCHMARK(addV2Clusters)
+    ->Ranges({{false, true}, {64, 100000}})
+    ->Unit(benchmark::kMillisecond)
+    ->Complexity();
+
+// Look for suboptimal behavior when receiving two identical updates
+static void duplicateUpdate(State& state) {
+  Envoy::Upstream::CdsSpeedTest speed_test(state, false);
+  const uint32_t num_clusters = skipExpensiveBenchmarks() ? 1 : state.range(0);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    state.PauseTiming();
+
+    speed_test.clusterHelper(true, num_clusters);
+    speed_test.clusterHelper(true, num_clusters);
+    state.ResumeTiming();
+  }
+}
+
+BENCHMARK(duplicateUpdate)->Range(64, 100000)->Unit(benchmark::kMillisecond)->Complexity();

test/common/upstream/eds_speed_test.cc

@@ -92,8 +92,6 @@ class EdsSpeedTest {
   // they are loaded as expected.
   void priorityAndLocalityWeightedHelper(bool ignore_unknown_dynamic_fields, size_t num_hosts,
                                          bool healthy) {
-    state_.PauseTiming();
-
     envoy::config::endpoint::v3::ClusterLoadAssignment cluster_load_assignment;
     cluster_load_assignment.set_cluster_name("fare");
 
@@ -136,6 +134,7 @@ class EdsSpeedTest {
     }
     state_.ResumeTiming();
     grpc_mux_->grpcStreamForTest().onReceiveMessage(std::move(response));
+    state_.PauseTiming();
     ASSERT(cluster_->prioritySet().hostSetsPerPriority()[1]->hostsPerLocality().get()[0].size() ==
            num_hosts);
   }
@@ -174,49 +173,45 @@ class EdsSpeedTest {
 } // namespace Envoy
 
 static void priorityAndLocalityWeighted(State& state) {
-  Envoy::Thread::MutexBasicLockable lock;
-  Envoy::Logger::Context logging_state(spdlog::level::warn,
-                                       Envoy::Logger::Logger::DEFAULT_LOG_FORMAT, lock, false);
-  for (auto _ : state) {
-    Envoy::Upstream::EdsSpeedTest speed_test(state, state.range(0));
-    // if we've been instructed to skip tests, only run once no matter the argument:
-    uint32_t endpoints = skipExpensiveBenchmarks() ? 1 : state.range(2);
-
-    speed_test.priorityAndLocalityWeightedHelper(state.range(1), endpoints, true);
+  Envoy::Upstream::EdsSpeedTest speed_test(state, state.range(0));
+  // if we've been instructed to skip tests, only run once no matter the argument:
+  const uint32_t num_endpoints = skipExpensiveBenchmarks() ? 1 : state.range(2);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    state.PauseTiming();
+
+    speed_test.priorityAndLocalityWeightedHelper(state.range(1), num_endpoints, true);
+    state.ResumeTiming();
   }
 }
 
 BENCHMARK(priorityAndLocalityWeighted)
-    ->Ranges({{false, true}, {false, true}, {1, 100000}})
+    ->Ranges({{false, true}, {false, true}, {64, 100000}})
     ->Unit(benchmark::kMillisecond);
 
 static void duplicateUpdate(State& state) {
-  Envoy::Thread::MutexBasicLockable lock;
-  Envoy::Logger::Context logging_state(spdlog::level::warn,
-                                       Envoy::Logger::Logger::DEFAULT_LOG_FORMAT, lock, false);
-
-  for (auto _ : state) {
-    Envoy::Upstream::EdsSpeedTest speed_test(state, false);
-    uint32_t endpoints = skipExpensiveBenchmarks() ? 1 : state.range(0);
-
-    speed_test.priorityAndLocalityWeightedHelper(true, endpoints, true);
-    speed_test.priorityAndLocalityWeightedHelper(true, endpoints, true);
+  Envoy::Upstream::EdsSpeedTest speed_test(state, false);
+  const uint32_t num_endpoints = skipExpensiveBenchmarks() ? 1 : state.range(0);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    state.PauseTiming();
+
+    speed_test.priorityAndLocalityWeightedHelper(true, num_endpoints, true);
+    speed_test.priorityAndLocalityWeightedHelper(true, num_endpoints, true);
+    state.ResumeTiming();
   }
 }
 
-BENCHMARK(duplicateUpdate)->Range(1, 100000)->Unit(benchmark::kMillisecond);
+BENCHMARK(duplicateUpdate)->Range(64, 100000)->Unit(benchmark::kMillisecond);
 
 static void healthOnlyUpdate(State& state) {
-  Envoy::Thread::MutexBasicLockable lock;
-  Envoy::Logger::Context logging_state(spdlog::level::warn,
-                                       Envoy::Logger::Logger::DEFAULT_LOG_FORMAT, lock, false);
-  for (auto _ : state) {
-    Envoy::Upstream::EdsSpeedTest speed_test(state, false);
-    uint32_t endpoints = skipExpensiveBenchmarks() ? 1 : state.range(0);
-
-    speed_test.priorityAndLocalityWeightedHelper(true, endpoints, true);
-    speed_test.priorityAndLocalityWeightedHelper(true, endpoints, false);
+  Envoy::Upstream::EdsSpeedTest speed_test(state, false);
+  const uint32_t num_endpoints = skipExpensiveBenchmarks() ? 1 : state.range(0);
+  for (auto _ : state) { // NOLINT(clang-analyzer-deadcode.DeadStores)
+    state.PauseTiming();
+
+    speed_test.priorityAndLocalityWeightedHelper(true, num_endpoints, true);
+    speed_test.priorityAndLocalityWeightedHelper(true, num_endpoints, false);
+    state.ResumeTiming();
   }
 }
 
-BENCHMARK(healthOnlyUpdate)->Range(1, 100000)->Unit(benchmark::kMillisecond);
+BENCHMARK(healthOnlyUpdate)->Range(64, 100000)->Unit(benchmark::kMillisecond);

tools/spelling/spelling_dictionary.txt

@@ -523,6 +523,7 @@ deallocate
 deallocated
 deallocating
 deallocation
+deadcode
 dec
 dechunk
 dechunked