From 1a479162bbdb68a7f494f605db0c3f719f59eb08 Mon Sep 17 00:00:00 2001 From: Eugene Ostroukhov Date: Wed, 19 Feb 2025 08:19:24 -0800 Subject: [PATCH 1/5] Bump core version 202502181609 (#38775) Closes #38775 COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/38775 from eugeneo:bump_core_version_202502181609 b92eb50abeb926bef1fd6b65d1d835370e7e89d5 PiperOrigin-RevId: 728681490 --- BUILD | 2 +- CMakeLists.txt | 4 ++-- Makefile | 8 ++++---- build_config.rb | 2 +- build_handwritten.yaml | 2 +- src/core/lib/surface/version.cc | 2 +- src/objective-c/tests/version.h | 2 +- tools/doxygen/Doxyfile.core | 2 +- tools/doxygen/Doxyfile.core.internal | 2 +- 9 files changed, 13 insertions(+), 13 deletions(-) diff --git a/BUILD b/BUILD index 4745cc2dd5f2b..9225acb08dc70 100644 --- a/BUILD +++ b/BUILD @@ -199,7 +199,7 @@ python_config_settings() # This should be updated along with build_handwritten.yaml g_stands_for = "gears" # @unused -core_version = "45.0.0" # @unused +core_version = "46.0.0" # @unused version = "1.71.0-dev" # @unused diff --git a/CMakeLists.txt b/CMakeLists.txt index e3dcbb2ac0b0b..f93fa48c222c3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,8 +26,8 @@ cmake_minimum_required(VERSION 3.16) set(PACKAGE_NAME "grpc") set(PACKAGE_VERSION "1.71.0-dev") -set(gRPC_CORE_VERSION "45.0.0") -set(gRPC_CORE_SOVERSION "45") +set(gRPC_CORE_VERSION "46.0.0") +set(gRPC_CORE_SOVERSION "46") set(gRPC_CPP_VERSION "1.71.0-dev") set(gRPC_CPP_SOVERSION "1.71") set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}") diff --git a/Makefile b/Makefile index 5caa7c00300b1..0b3011982e0e7 100644 --- a/Makefile +++ b/Makefile @@ -367,7 +367,7 @@ E = @echo Q = @ endif -CORE_VERSION = 45.0.0 +CORE_VERSION = 46.0.0 CPP_VERSION = 1.71.0-dev CPPFLAGS_NO_ARCH += $(addprefix -I, $(INCLUDES)) $(addprefix -D, $(DEFINES)) @@ -404,7 +404,7 @@ SHARED_EXT_CORE = dll SHARED_EXT_CPP = dll SHARED_PREFIX = -SHARED_VERSION_CORE = -45 +SHARED_VERSION_CORE = -46 SHARED_VERSION_CPP = -1 else ifeq ($(SYSTEM),Darwin) EXECUTABLE_SUFFIX = @@ -1827,8 +1827,8 @@ $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE): $(LIBGRPC_ ifeq ($(SYSTEM),Darwin) $(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -install_name $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) -dynamiclib -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS) else - $(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.45 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS) - $(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.45 + $(Q) $(LDXX) $(LDFLAGS) -L$(LIBDIR)/$(CONFIG) -shared -Wl,-soname,libgrpc.so.46 -o $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBGRPC_OBJS) $(LIBDIR)/$(CONFIG)/libcares.a $(OPENSSL_MERGE_LIBS) $(ZLIB_MERGE_LIBS) $(LDLIBS_SECURE) $(LDLIBS) + $(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so.46 $(Q) ln -sf $(SHARED_PREFIX)grpc$(SHARED_VERSION_CORE).$(SHARED_EXT_CORE) $(LIBDIR)/$(CONFIG)/libgrpc$(SHARED_VERSION_CORE).so endif endif diff --git a/build_config.rb b/build_config.rb index 389a937a5fd42..cc1f051b79ed2 100644 --- a/build_config.rb +++ b/build_config.rb @@ -13,5 +13,5 @@ # limitations under the License. module GrpcBuildConfig - CORE_WINDOWS_DLL = '/tmp/libs/opt/grpc-45.dll' + CORE_WINDOWS_DLL = '/tmp/libs/opt/grpc-46.dll' end diff --git a/build_handwritten.yaml b/build_handwritten.yaml index 39b6a933a3169..6f1cd80839ad9 100644 --- a/build_handwritten.yaml +++ b/build_handwritten.yaml @@ -12,7 +12,7 @@ settings: '#08': Use "-preN" suffixes to identify pre-release versions '#09': Per-language overrides are possible with (eg) ruby_version tag here '#10': See the expand_version.py for all the quirks here - core_version: 45.0.0 + core_version: 46.0.0 csharp_major_version: 2 g_stands_for: gears protobuf_version: 3.29.0 diff --git a/src/core/lib/surface/version.cc b/src/core/lib/surface/version.cc index d4c4e5b829a5d..87781db5c01a7 100644 --- a/src/core/lib/surface/version.cc +++ b/src/core/lib/surface/version.cc @@ -22,6 +22,6 @@ #include #include -const char* grpc_version_string(void) { return "45.0.0"; } +const char* grpc_version_string(void) { return "46.0.0"; } const char* grpc_g_stands_for(void) { return "gears"; } diff --git a/src/objective-c/tests/version.h b/src/objective-c/tests/version.h index 961b85ea81d07..82c0024c0498d 100644 --- a/src/objective-c/tests/version.h +++ b/src/objective-c/tests/version.h @@ -23,4 +23,4 @@ // `tools/buildgen/generate_projects.sh`. #define GRPC_OBJC_VERSION_STRING @"1.71.0-dev" -#define GRPC_C_VERSION_STRING @"45.0.0" +#define GRPC_C_VERSION_STRING @"46.0.0" diff --git a/tools/doxygen/Doxyfile.core b/tools/doxygen/Doxyfile.core index a04a3539aaff2..56228e297c5c6 100644 --- a/tools/doxygen/Doxyfile.core +++ b/tools/doxygen/Doxyfile.core @@ -40,7 +40,7 @@ PROJECT_NAME = "GRPC Core" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 45.0.0 +PROJECT_NUMBER = 46.0.0 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a diff --git a/tools/doxygen/Doxyfile.core.internal b/tools/doxygen/Doxyfile.core.internal index 8c6478734ac2b..d5d22b8a1eb90 100644 --- a/tools/doxygen/Doxyfile.core.internal +++ b/tools/doxygen/Doxyfile.core.internal @@ -40,7 +40,7 @@ PROJECT_NAME = "GRPC Core" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 45.0.0 +PROJECT_NUMBER = 46.0.0 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a From 94b9b62f67b82ac05ec381fb63b7faf8d56d8f8d Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Wed, 19 Feb 2025 09:57:35 -0800 Subject: [PATCH 2/5] [promises] Simplify switch debugging (#38755) Switch to codegen so it's more obvious what goes on inside of a Switch function. Closes #38755 COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/38755 from ctiller:switch cb2520c27f5f8360442ebd48b841fe08fe9316f2 PiperOrigin-RevId: 728712231 --- src/core/lib/promise/switch.h | 701 ++++++++++++++++++++++++++++++- tools/codegen/core/BUILD | 5 + tools/codegen/core/gen_switch.cc | 172 ++++++++ 3 files changed, 862 insertions(+), 16 deletions(-) create mode 100644 tools/codegen/core/gen_switch.cc diff --git a/src/core/lib/promise/switch.h b/src/core/lib/promise/switch.h index c2bb45776f295..6fe45d5f8a15f 100644 --- a/src/core/lib/promise/switch.h +++ b/src/core/lib/promise/switch.h @@ -1,4 +1,4 @@ -// Copyright 2023 gRPC authors. +// Copyright 2025 gRPC authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -73,14 +73,12 @@ namespace grpc_core { // discriminator value. However this should be avoided as it could lead to bugs. namespace promise_detail { -template +template struct Case { using Factory = OncePromiseFactory; explicit Case(F f) : factory(std::move(f)) {} Factory factory; - static bool Matches(decltype(kDiscriminator) value) { - return value == kDiscriminator; - } + static constexpr const decltype(D) kDiscriminator = D; }; template @@ -89,16 +87,689 @@ struct Default { explicit Default(F f) : factory(std::move(f)) {} Factory factory; }; - -template -Promise ConstructSwitchPromise(D, Default& def) { - return def.factory.Make(); +template +Promise ConstructSwitchPromise(D discriminator, Default& default_case) { + switch (discriminator) { + default: + return default_case.factory.Make(); + } } - -template -Promise ConstructSwitchPromise(D discriminator, Case& c, OtherCases&... cs) { - if (Case::Matches(discriminator)) return c.factory.Make(); - return ConstructSwitchPromise(discriminator, cs...); +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Case& case_13, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Case& case_13, Case& case_14, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + case Case::kDiscriminator: + return case_14.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Case& case_13, Case& case_14, + Case& case_15, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + case Case::kDiscriminator: + return case_14.factory.Make(); + case Case::kDiscriminator: + return case_15.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Case& case_13, Case& case_14, + Case& case_15, Case& case_16, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + case Case::kDiscriminator: + return case_14.factory.Make(); + case Case::kDiscriminator: + return case_15.factory.Make(); + case Case::kDiscriminator: + return case_16.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise( + D discriminator, Case& case_0, Case& case_1, + Case& case_2, Case& case_3, Case& case_4, + Case& case_5, Case& case_6, Case& case_7, + Case& case_8, Case& case_9, Case& case_10, + Case& case_11, Case& case_12, Case& case_13, + Case& case_14, Case& case_15, Case& case_16, + Case& case_17, Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + case Case::kDiscriminator: + return case_14.factory.Make(); + case Case::kDiscriminator: + return case_15.factory.Make(); + case Case::kDiscriminator: + return case_16.factory.Make(); + case Case::kDiscriminator: + return case_17.factory.Make(); + default: + return default_case.factory.Make(); + } +} +template +Promise ConstructSwitchPromise(D discriminator, Case& case_0, + Case& case_1, Case& case_2, + Case& case_3, Case& case_4, + Case& case_5, Case& case_6, + Case& case_7, Case& case_8, + Case& case_9, Case& case_10, + Case& case_11, Case& case_12, + Case& case_13, Case& case_14, + Case& case_15, Case& case_16, + Case& case_17, Case& case_18, + Default& default_case) { + switch (discriminator) { + case Case::kDiscriminator: + return case_0.factory.Make(); + case Case::kDiscriminator: + return case_1.factory.Make(); + case Case::kDiscriminator: + return case_2.factory.Make(); + case Case::kDiscriminator: + return case_3.factory.Make(); + case Case::kDiscriminator: + return case_4.factory.Make(); + case Case::kDiscriminator: + return case_5.factory.Make(); + case Case::kDiscriminator: + return case_6.factory.Make(); + case Case::kDiscriminator: + return case_7.factory.Make(); + case Case::kDiscriminator: + return case_8.factory.Make(); + case Case::kDiscriminator: + return case_9.factory.Make(); + case Case::kDiscriminator: + return case_10.factory.Make(); + case Case::kDiscriminator: + return case_11.factory.Make(); + case Case::kDiscriminator: + return case_12.factory.Make(); + case Case::kDiscriminator: + return case_13.factory.Make(); + case Case::kDiscriminator: + return case_14.factory.Make(); + case Case::kDiscriminator: + return case_15.factory.Make(); + case Case::kDiscriminator: + return case_16.factory.Make(); + case Case::kDiscriminator: + return case_17.factory.Make(); + case Case::kDiscriminator: + return case_18.factory.Make(); + default: + return default_case.factory.Make(); + } } template @@ -120,8 +791,6 @@ auto Default(PromiseFactory f) { return promise_detail::Default{std::move(f)}; } -// TODO(ctiller): consider writing a code-generator like we do for seq/join -// so that this lowers into a C switch statement. template auto Switch(D discriminator, C... cases) { return promise_detail::SwitchImpl(discriminator, cases...); diff --git a/tools/codegen/core/BUILD b/tools/codegen/core/BUILD index 1e95fcf88eab9..d1399373043d0 100644 --- a/tools/codegen/core/BUILD +++ b/tools/codegen/core/BUILD @@ -39,3 +39,8 @@ grpc_cc_binary( "//src/core:match", ], ) + +grpc_cc_binary( + name = "gen_switch", + srcs = ["gen_switch.cc"], +) diff --git a/tools/codegen/core/gen_switch.cc b/tools/codegen/core/gen_switch.cc new file mode 100644 index 0000000000000..dbcedc17130ff --- /dev/null +++ b/tools/codegen/core/gen_switch.cc @@ -0,0 +1,172 @@ +// Copyright 2025 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 +#include + +const char* kPrefix = R"(// Copyright 2025 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_SRC_CORE_LIB_PROMISE_SWITCH_H +#define GRPC_SRC_CORE_LIB_PROMISE_SWITCH_H + +#include + +#include +#include + +#include "src/core/lib/promise/detail/promise_factory.h" +#include "src/core/lib/promise/detail/promise_variant.h" +#include "src/core/lib/promise/if.h" +#include "src/core/util/crash.h" + +namespace grpc_core { + +// Switch promise combinator +// +// Input : +// +// 1. The first input is the Switch discriminator. Only data types that can be +// used with a C++ switch statement can be passed as the discriminator. +// 2. Then we can pass zero or more objects of type Case as inputs. The Case +// object is a promise factory. +// 3. One object of type Default. +// +// Returns : +// Returns a promise that is chosen based on the discriminator. +// +// How it works : +// Given a discriminator, the Switch combinator tries to find a matching Case. +// If a matching Case is found, then the promise corresponding to the matching +// Case is returned. +// If a matching Case is not found, the promise corresponding to the Default is +// returned. +// +// Example : +// +// TEST(SwitchTest, Sample) { +// auto test_switch = [](int discriminator) { +// return Switch(discriminator, +// Case<1>([] { return 100; }), +// Case<2>([] { return 200; }), +// Case<3>([]() -> Poll { return Pending{}; }), +// Default([] { return -1; })); +// }; +// EXPECT_EQ(test_switch(1)(), Poll(100)); +// EXPECT_EQ(test_switch(2)(), Poll(200)); +// EXPECT_EQ(test_switch(3)(), Poll(Pending{})); +// EXPECT_EQ(test_switch(4)(), Poll(-1)); +// } +// +// All Case objects and the Default object must have the same Poll return +// type. +// +// The fallthrough mechanism is present in C++ switch statements is NOT present +// in the Switch promise combinator. +// +// Our code currently permits you to create multiple cases for the same +// discriminator value. However this should be avoided as it could lead to bugs. + +namespace promise_detail { +template +struct Case { + using Factory = OncePromiseFactory; + explicit Case(F f) : factory(std::move(f)) {} + Factory factory; + static constexpr const decltype(D) kDiscriminator = D; +}; + +template +struct Default { + using Factory = OncePromiseFactory; + explicit Default(F f) : factory(std::move(f)) {} + Factory factory; +}; +)"; + +static const char* kSuffix = R"( +template +auto SwitchImpl(D discriminator, Cases&... cases) { + using Promise = std::variant; + return PromiseVariant( + ConstructSwitchPromise(discriminator, cases...)); +} + +} // namespace promise_detail + +template +auto Case(PromiseFactory f) { + return promise_detail::Case{std::move(f)}; +} + +template +auto Default(PromiseFactory f) { + return promise_detail::Default{std::move(f)}; +} + +template +auto Switch(D discriminator, C... cases) { + return promise_detail::SwitchImpl(discriminator, cases...); +} + +} // namespace grpc_core + +#endif // GRPC_SRC_CORE_LIB_PROMISE_SWITCH_H +)"; + +std::string Switch(int n) { + std::string out = "template & case_" + istr; + } + out += ", Default& default_case) {\n"; + out += " switch (discriminator) {\n"; + for (int i=0; i::kDiscriminator: return case_" + istr + ".factory.Make();\n"; + } + + out += " default: return default_case.factory.Make();\n"; + out += " }"; + out += "}\n"; + return out; +} + +int main() { + std::string out = kPrefix; + for (int i=0; i<20; i++) { + out += Switch(i); + } + out += kSuffix; + printf("%s\n", out.c_str()); + return 0; +} From 82476f97039bcb41ac77646611de94745afc74ec Mon Sep 17 00:00:00 2001 From: Vignesh Babu Date: Wed, 19 Feb 2025 10:02:33 -0800 Subject: [PATCH 3/5] [Experiments] Bump experiment expiry (#38773) Closes #38773 COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/38773 from Vignesh2208:outdate 4b914cbeeef052b9397b6430f7a2966fedf9e91b PiperOrigin-RevId: 728714158 --- src/core/lib/experiments/experiments.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/core/lib/experiments/experiments.yaml b/src/core/lib/experiments/experiments.yaml index 58cedd8e57fe2..01a32d249a418 100644 --- a/src/core/lib/experiments/experiments.yaml +++ b/src/core/lib/experiments/experiments.yaml @@ -103,7 +103,7 @@ description: Avoid explicitly cancelling the keepalive timer. Instead adjust the callback to re-schedule itself to the next ping interval. - expiry: 2025/03/01 + expiry: 2025/06/01 owner: vigneshbabu@google.com test_tags: [] - name: local_connector_secure @@ -184,7 +184,7 @@ test_tags: [] - name: schedule_cancellation_over_write description: Allow cancellation op to be scheduled over a write - expiry: 2025/03/01 + expiry: 2025/06/01 owner: vigneshbabu@google.com test_tags: [] - name: server_listener @@ -198,12 +198,12 @@ TCP would not indicate completion of a read operation until a specified number of bytes have been read over the socket. Buffers are also allocated according to estimated RPC sizes. - expiry: 2025/03/01 + expiry: 2025/06/01 owner: vigneshbabu@google.com test_tags: ["endpoint_test", "flow_control_test"] - name: tcp_rcv_lowat description: Use SO_RCVLOWAT to avoid wakeups on the read path. - expiry: 2025/03/01 + expiry: 2025/06/01 owner: vigneshbabu@google.com test_tags: ["endpoint_test", "flow_control_test"] - name: trace_record_callops From a88e559e01b593a529f9d2b22b50b94d7dc71f0d Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Wed, 19 Feb 2025 12:02:35 -0800 Subject: [PATCH 4/5] [RLS] cleanup WorkSerializer usage (#38782) I just happened to notice this while working on something else. Now that the WorkSerializer always runs callback asynchronously, there's no need for the extra hop through ExecCtx here. Closes #38782 COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/38782 from markdroth:rls_work_serializer_cleanup 5487a8bf951c8dd321aa6ddc581477547e3445c9 PiperOrigin-RevId: 728762272 --- src/core/load_balancing/rls/rls.cc | 29 +++++++---------------------- 1 file changed, 7 insertions(+), 22 deletions(-) diff --git a/src/core/load_balancing/rls/rls.cc b/src/core/load_balancing/rls/rls.cc index c5aa1e58f7957..0d0600af3db3f 100644 --- a/src/core/load_balancing/rls/rls.cc +++ b/src/core/load_balancing/rls/rls.cc @@ -684,12 +684,10 @@ class RlsLb final : public LoadBalancingPolicy { void ShutdownLocked() override; - // Returns a new picker to the channel to trigger reprocessing of - // pending picks. Schedules the actual picker update on the ExecCtx - // to be run later, so it's safe to invoke this while holding the lock. + // Schedules a call to UpdatePickerLocked() on the WorkSerializer. + // The call will be run asynchronously, so it's safe to invoke this + // while holding the lock. void UpdatePickerAsync(); - // Hops into work serializer and calls UpdatePickerLocked(). - static void UpdatePickerCallback(void* arg, grpc_error_handle error); // Updates the picker in the work serializer. void UpdatePickerLocked() ABSL_LOCKS_EXCLUDED(&mu_); @@ -2057,23 +2055,10 @@ void RlsLb::ShutdownLocked() { } void RlsLb::UpdatePickerAsync() { - // Run via the ExecCtx, since the caller may be holding the lock, and - // we don't want to be doing that when we hop into the WorkSerializer, - // in case the WorkSerializer callback happens to run inline. - ExecCtx::Run( - DEBUG_LOCATION, - GRPC_CLOSURE_CREATE(UpdatePickerCallback, - Ref(DEBUG_LOCATION, "UpdatePickerCallback").release(), - grpc_schedule_on_exec_ctx), - absl::OkStatus()); -} - -void RlsLb::UpdatePickerCallback(void* arg, grpc_error_handle /*error*/) { - auto* rls_lb = static_cast(arg); - rls_lb->work_serializer()->Run([rls_lb]() { - RefCountedPtr lb_policy(rls_lb); - lb_policy->UpdatePickerLocked(); - lb_policy.reset(DEBUG_LOCATION, "UpdatePickerCallback"); + work_serializer()->Run([self = RefAsSubclass( + DEBUG_LOCATION, "UpdatePickerAsync")]() mutable { + self->UpdatePickerLocked(); + self.reset(DEBUG_LOCATION, "UpdatePickerAsync"); }); } From dbb582a7e0c24fabbf8080617ab7125ab54f4ebe Mon Sep 17 00:00:00 2001 From: Vignesh Babu Date: Wed, 19 Feb 2025 12:52:14 -0800 Subject: [PATCH 5/5] [Experiments] Remove unused experiments and experiments which are aleady default set to true PiperOrigin-RevId: 728780597 --- bazel/experiments.bzl | 3 - .../chttp2/transport/chttp2_transport.cc | 20 +----- .../chttp2/transport/stream_lists.cc | 40 +----------- .../ext/transport/chttp2/transport/writing.cc | 4 +- src/core/lib/experiments/experiments.cc | 63 ------------------- src/core/lib/experiments/experiments.h | 28 --------- src/core/lib/experiments/experiments.yaml | 16 ----- src/core/lib/experiments/rollouts.yaml | 6 -- .../census/stats_plugin_end2end_test.cc | 1 - 9 files changed, 4 insertions(+), 177 deletions(-) diff --git a/bazel/experiments.bzl b/bazel/experiments.bzl index 0b9c380baf6f2..5940eef45369a 100644 --- a/bazel/experiments.bzl +++ b/bazel/experiments.bzl @@ -20,7 +20,6 @@ EXPERIMENT_ENABLES = { "backoff_cap_initial_at_max": "backoff_cap_initial_at_max", "call_tracer_in_transport": "call_tracer_in_transport", "callv3_client_auth_filter": "callv3_client_auth_filter", - "disable_buffer_hint_on_high_memory_pressure": "disable_buffer_hint_on_high_memory_pressure", "event_engine_client": "event_engine_client", "event_engine_dns": "event_engine_dns", "event_engine_dns_non_client_channel": "event_engine_dns_non_client_channel", @@ -34,7 +33,6 @@ EXPERIMENT_ENABLES = { "multiping": "multiping", "pick_first_new": "pick_first_new", "posix_ee_skip_grpc_init": "posix_ee_skip_grpc_init", - "prioritize_finished_requests": "prioritize_finished_requests", "promise_based_http2_client_transport": "promise_based_http2_client_transport", "promise_based_http2_server_transport": "promise_based_http2_server_transport", "promise_based_inproc_transport": "promise_based_inproc_transport", @@ -44,7 +42,6 @@ EXPERIMENT_ENABLES = { "server_listener": "server_listener", "tcp_frame_size_tuning": "tcp_frame_size_tuning", "tcp_rcv_lowat": "tcp_rcv_lowat", - "trace_record_callops": "trace_record_callops", "unconstrained_max_quota_buffer_size": "unconstrained_max_quota_buffer_size", } diff --git a/src/core/ext/transport/chttp2/transport/chttp2_transport.cc b/src/core/ext/transport/chttp2/transport/chttp2_transport.cc index d8432c8247c1f..5b8d5e8998103 100644 --- a/src/core/ext/transport/chttp2/transport/chttp2_transport.cc +++ b/src/core/ext/transport/chttp2/transport/chttp2_transport.cc @@ -229,9 +229,6 @@ using TaskHandle = ::grpc_event_engine::experimental::EventEngine::TaskHandle; grpc_core::CallTracerAnnotationInterface* CallTracerIfSampled( grpc_chttp2_stream* s) { - if (!grpc_core::IsTraceRecordCallopsEnabled()) { - return nullptr; - } auto* call_tracer = s->arena->GetContext(); if (call_tracer == nullptr || !call_tracer->IsSampled()) { @@ -242,9 +239,6 @@ grpc_core::CallTracerAnnotationInterface* CallTracerIfSampled( std::shared_ptr TcpTracerIfSampled( grpc_chttp2_stream* s) { - if (!grpc_core::IsTraceRecordCallopsEnabled()) { - return nullptr; - } auto* call_attempt_tracer = s->arena->GetContext(); if (call_attempt_tracer == nullptr || !call_attempt_tracer->IsSampled()) { @@ -1395,7 +1389,7 @@ static void trace_annotations(grpc_chttp2_stream* s) { .Add(s->t->flow_control.stats()) .Add(s->flow_control.stats())); } - } else if (grpc_core::IsTraceRecordCallopsEnabled()) { + } else { auto* call_tracer = s->arena->GetContext(); if (call_tracer != nullptr && call_tracer->IsSampled()) { call_tracer->RecordAnnotation( @@ -1504,18 +1498,6 @@ static void send_message_locked( absl::OkStatus(), "fetching_send_message_finished"); } else { - // Buffer hint is used to buffer the message in the transport until the - // write buffer size (specified through GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE) is - // reached. This is to batch writes sent down to tcp. However, if the memory - // pressure is high, disable the buffer hint to flush data down to tcp as - // soon as possible to avoid OOM. - if (grpc_core::IsDisableBufferHintOnHighMemoryPressureEnabled() && - t->memory_owner.GetPressureInfo().pressure_control_value >= 0.8) { - // Disable write buffer hint if memory pressure is high. The value of 0.8 - // is chosen to match the threshold used by the tcp endpoint (in - // allocating memory for socket reads). - op_payload->send_message.flags &= ~GRPC_WRITE_BUFFER_HINT; - } flags = op_payload->send_message.flags; uint8_t* frame_hdr = grpc_slice_buffer_tiny_add(&s->flow_controlled_buffer, GRPC_HEADER_SIZE_IN_BYTES); diff --git a/src/core/ext/transport/chttp2/transport/stream_lists.cc b/src/core/ext/transport/chttp2/transport/stream_lists.cc index 4ff249fa870bf..20d848c35bb11 100644 --- a/src/core/ext/transport/chttp2/transport/stream_lists.cc +++ b/src/core/ext/transport/chttp2/transport/stream_lists.cc @@ -128,26 +128,6 @@ static void stream_list_add_tail(grpc_chttp2_transport* t, << "]: add to " << stream_list_id_string(id); } -static void stream_list_add_head(grpc_chttp2_transport* t, - grpc_chttp2_stream* s, - grpc_chttp2_stream_list_id id) { - grpc_chttp2_stream* old_head; - CHECK(!s->included.is_set(id)); - old_head = t->lists[id].head; - s->links[id].next = old_head; - s->links[id].prev = nullptr; - if (old_head) { - old_head->links[id].prev = s; - } else { - t->lists[id].tail = s; - } - t->lists[id].head = s; - s->included.set(id); - GRPC_TRACE_LOG(http2_stream_state, INFO) - << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr") - << "]: add to " << stream_list_id_string(id); -} - static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s, grpc_chttp2_stream_list_id id) { if (s->included.is_set(id)) { @@ -157,24 +137,11 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s, return true; } -static bool stream_list_prepend(grpc_chttp2_transport* t, grpc_chttp2_stream* s, - grpc_chttp2_stream_list_id id) { - if (s->included.is_set(id)) { - return false; - } - stream_list_add_head(t, s, id); - return true; -} - // wrappers for specializations bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t, grpc_chttp2_stream* s) { CHECK_NE(s->id, 0u); - if (grpc_core::IsPrioritizeFinishedRequestsEnabled() && - s->send_trailing_metadata != nullptr) { - return stream_list_prepend(t, s, GRPC_CHTTP2_LIST_WRITABLE); - } return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE); } @@ -219,12 +186,7 @@ void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t, void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t, grpc_chttp2_stream* s) { - if (grpc_core::IsPrioritizeFinishedRequestsEnabled() && - s->send_trailing_metadata != nullptr) { - stream_list_prepend(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); - } else { - stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); - } + stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT); } bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport* t, diff --git a/src/core/ext/transport/chttp2/transport/writing.cc b/src/core/ext/transport/chttp2/transport/writing.cc index fe0000baf9e69..96dbe82127f98 100644 --- a/src/core/ext/transport/chttp2/transport/writing.cc +++ b/src/core/ext/transport/chttp2/transport/writing.cc @@ -484,7 +484,7 @@ class StreamWriteContext { .Add(s_->flow_control.stats()) .Add(write_stats)); } - } else if (grpc_core::IsTraceRecordCallopsEnabled()) { + } else { auto* call_tracer = s_->arena->GetContext(); if (call_tracer != nullptr && call_tracer->IsSampled()) { @@ -646,7 +646,7 @@ class StreamWriteContext { .Add(s_->t->flow_control.stats()) .Add(s_->flow_control.stats())); } - } else if (grpc_core::IsTraceRecordCallopsEnabled()) { + } else { auto* call_tracer = s_->arena->GetContext(); if (call_tracer != nullptr && call_tracer->IsSampled()) { diff --git a/src/core/lib/experiments/experiments.cc b/src/core/lib/experiments/experiments.cc index 9652ae88a6e4b..948490317b04d 100644 --- a/src/core/lib/experiments/experiments.cc +++ b/src/core/lib/experiments/experiments.cc @@ -32,11 +32,6 @@ const char* const additional_constraints_call_tracer_in_transport = "{}"; const char* const description_callv3_client_auth_filter = "Use the CallV3 client auth filter."; const char* const additional_constraints_callv3_client_auth_filter = "{}"; -const char* const description_disable_buffer_hint_on_high_memory_pressure = - "Disable buffer hint flag parsing in the transport under high memory " - "pressure."; -const char* const - additional_constraints_disable_buffer_hint_on_high_memory_pressure = "{}"; const char* const description_event_engine_client = "Use EventEngine clients instead of iomgr's grpc_tcp_client"; const char* const additional_constraints_event_engine_client = "{}"; @@ -86,10 +81,6 @@ const char* const description_posix_ee_skip_grpc_init = "Prevent the PosixEventEngine from calling grpc_init & grpc_shutdown on " "creation and destruction."; const char* const additional_constraints_posix_ee_skip_grpc_init = "{}"; -const char* const description_prioritize_finished_requests = - "Prioritize flushing out finished requests over other in-flight requests " - "during transport writes."; -const char* const additional_constraints_prioritize_finished_requests = "{}"; const char* const description_promise_based_http2_client_transport = "Use promises for the http2 client transport. We have kept client and " "server transport experiments separate to help with smoother roll outs and " @@ -127,9 +118,6 @@ const char* const additional_constraints_tcp_frame_size_tuning = "{}"; const char* const description_tcp_rcv_lowat = "Use SO_RCVLOWAT to avoid wakeups on the read path."; const char* const additional_constraints_tcp_rcv_lowat = "{}"; -const char* const description_trace_record_callops = - "Enables tracing of call batch initiation and completion."; -const char* const additional_constraints_trace_record_callops = "{}"; const char* const description_unconstrained_max_quota_buffer_size = "Discard the cap on the max free pool size for one memory allocator"; const char* const additional_constraints_unconstrained_max_quota_buffer_size = @@ -145,10 +133,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_call_tracer_in_transport, nullptr, 0, true, true}, {"callv3_client_auth_filter", description_callv3_client_auth_filter, additional_constraints_callv3_client_auth_filter, nullptr, 0, false, true}, - {"disable_buffer_hint_on_high_memory_pressure", - description_disable_buffer_hint_on_high_memory_pressure, - additional_constraints_disable_buffer_hint_on_high_memory_pressure, - nullptr, 0, false, true}, {"event_engine_client", description_event_engine_client, additional_constraints_event_engine_client, nullptr, 0, false, false}, {"event_engine_dns", description_event_engine_dns, @@ -179,9 +163,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_pick_first_new, nullptr, 0, true, true}, {"posix_ee_skip_grpc_init", description_posix_ee_skip_grpc_init, additional_constraints_posix_ee_skip_grpc_init, nullptr, 0, false, true}, - {"prioritize_finished_requests", description_prioritize_finished_requests, - additional_constraints_prioritize_finished_requests, nullptr, 0, false, - true}, {"promise_based_http2_client_transport", description_promise_based_http2_client_transport, additional_constraints_promise_based_http2_client_transport, nullptr, 0, @@ -208,8 +189,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_tcp_frame_size_tuning, nullptr, 0, false, true}, {"tcp_rcv_lowat", description_tcp_rcv_lowat, additional_constraints_tcp_rcv_lowat, nullptr, 0, false, true}, - {"trace_record_callops", description_trace_record_callops, - additional_constraints_trace_record_callops, nullptr, 0, true, true}, {"unconstrained_max_quota_buffer_size", description_unconstrained_max_quota_buffer_size, additional_constraints_unconstrained_max_quota_buffer_size, nullptr, 0, @@ -229,11 +208,6 @@ const char* const additional_constraints_call_tracer_in_transport = "{}"; const char* const description_callv3_client_auth_filter = "Use the CallV3 client auth filter."; const char* const additional_constraints_callv3_client_auth_filter = "{}"; -const char* const description_disable_buffer_hint_on_high_memory_pressure = - "Disable buffer hint flag parsing in the transport under high memory " - "pressure."; -const char* const - additional_constraints_disable_buffer_hint_on_high_memory_pressure = "{}"; const char* const description_event_engine_client = "Use EventEngine clients instead of iomgr's grpc_tcp_client"; const char* const additional_constraints_event_engine_client = "{}"; @@ -283,10 +257,6 @@ const char* const description_posix_ee_skip_grpc_init = "Prevent the PosixEventEngine from calling grpc_init & grpc_shutdown on " "creation and destruction."; const char* const additional_constraints_posix_ee_skip_grpc_init = "{}"; -const char* const description_prioritize_finished_requests = - "Prioritize flushing out finished requests over other in-flight requests " - "during transport writes."; -const char* const additional_constraints_prioritize_finished_requests = "{}"; const char* const description_promise_based_http2_client_transport = "Use promises for the http2 client transport. We have kept client and " "server transport experiments separate to help with smoother roll outs and " @@ -324,9 +294,6 @@ const char* const additional_constraints_tcp_frame_size_tuning = "{}"; const char* const description_tcp_rcv_lowat = "Use SO_RCVLOWAT to avoid wakeups on the read path."; const char* const additional_constraints_tcp_rcv_lowat = "{}"; -const char* const description_trace_record_callops = - "Enables tracing of call batch initiation and completion."; -const char* const additional_constraints_trace_record_callops = "{}"; const char* const description_unconstrained_max_quota_buffer_size = "Discard the cap on the max free pool size for one memory allocator"; const char* const additional_constraints_unconstrained_max_quota_buffer_size = @@ -342,10 +309,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_call_tracer_in_transport, nullptr, 0, true, true}, {"callv3_client_auth_filter", description_callv3_client_auth_filter, additional_constraints_callv3_client_auth_filter, nullptr, 0, false, true}, - {"disable_buffer_hint_on_high_memory_pressure", - description_disable_buffer_hint_on_high_memory_pressure, - additional_constraints_disable_buffer_hint_on_high_memory_pressure, - nullptr, 0, false, true}, {"event_engine_client", description_event_engine_client, additional_constraints_event_engine_client, nullptr, 0, true, false}, {"event_engine_dns", description_event_engine_dns, @@ -376,9 +339,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_pick_first_new, nullptr, 0, true, true}, {"posix_ee_skip_grpc_init", description_posix_ee_skip_grpc_init, additional_constraints_posix_ee_skip_grpc_init, nullptr, 0, false, true}, - {"prioritize_finished_requests", description_prioritize_finished_requests, - additional_constraints_prioritize_finished_requests, nullptr, 0, false, - true}, {"promise_based_http2_client_transport", description_promise_based_http2_client_transport, additional_constraints_promise_based_http2_client_transport, nullptr, 0, @@ -405,8 +365,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_tcp_frame_size_tuning, nullptr, 0, false, true}, {"tcp_rcv_lowat", description_tcp_rcv_lowat, additional_constraints_tcp_rcv_lowat, nullptr, 0, false, true}, - {"trace_record_callops", description_trace_record_callops, - additional_constraints_trace_record_callops, nullptr, 0, true, true}, {"unconstrained_max_quota_buffer_size", description_unconstrained_max_quota_buffer_size, additional_constraints_unconstrained_max_quota_buffer_size, nullptr, 0, @@ -426,11 +384,6 @@ const char* const additional_constraints_call_tracer_in_transport = "{}"; const char* const description_callv3_client_auth_filter = "Use the CallV3 client auth filter."; const char* const additional_constraints_callv3_client_auth_filter = "{}"; -const char* const description_disable_buffer_hint_on_high_memory_pressure = - "Disable buffer hint flag parsing in the transport under high memory " - "pressure."; -const char* const - additional_constraints_disable_buffer_hint_on_high_memory_pressure = "{}"; const char* const description_event_engine_client = "Use EventEngine clients instead of iomgr's grpc_tcp_client"; const char* const additional_constraints_event_engine_client = "{}"; @@ -480,10 +433,6 @@ const char* const description_posix_ee_skip_grpc_init = "Prevent the PosixEventEngine from calling grpc_init & grpc_shutdown on " "creation and destruction."; const char* const additional_constraints_posix_ee_skip_grpc_init = "{}"; -const char* const description_prioritize_finished_requests = - "Prioritize flushing out finished requests over other in-flight requests " - "during transport writes."; -const char* const additional_constraints_prioritize_finished_requests = "{}"; const char* const description_promise_based_http2_client_transport = "Use promises for the http2 client transport. We have kept client and " "server transport experiments separate to help with smoother roll outs and " @@ -521,9 +470,6 @@ const char* const additional_constraints_tcp_frame_size_tuning = "{}"; const char* const description_tcp_rcv_lowat = "Use SO_RCVLOWAT to avoid wakeups on the read path."; const char* const additional_constraints_tcp_rcv_lowat = "{}"; -const char* const description_trace_record_callops = - "Enables tracing of call batch initiation and completion."; -const char* const additional_constraints_trace_record_callops = "{}"; const char* const description_unconstrained_max_quota_buffer_size = "Discard the cap on the max free pool size for one memory allocator"; const char* const additional_constraints_unconstrained_max_quota_buffer_size = @@ -539,10 +485,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_call_tracer_in_transport, nullptr, 0, true, true}, {"callv3_client_auth_filter", description_callv3_client_auth_filter, additional_constraints_callv3_client_auth_filter, nullptr, 0, false, true}, - {"disable_buffer_hint_on_high_memory_pressure", - description_disable_buffer_hint_on_high_memory_pressure, - additional_constraints_disable_buffer_hint_on_high_memory_pressure, - nullptr, 0, false, true}, {"event_engine_client", description_event_engine_client, additional_constraints_event_engine_client, nullptr, 0, true, false}, {"event_engine_dns", description_event_engine_dns, @@ -573,9 +515,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_pick_first_new, nullptr, 0, true, true}, {"posix_ee_skip_grpc_init", description_posix_ee_skip_grpc_init, additional_constraints_posix_ee_skip_grpc_init, nullptr, 0, false, true}, - {"prioritize_finished_requests", description_prioritize_finished_requests, - additional_constraints_prioritize_finished_requests, nullptr, 0, false, - true}, {"promise_based_http2_client_transport", description_promise_based_http2_client_transport, additional_constraints_promise_based_http2_client_transport, nullptr, 0, @@ -602,8 +541,6 @@ const ExperimentMetadata g_experiment_metadata[] = { additional_constraints_tcp_frame_size_tuning, nullptr, 0, false, true}, {"tcp_rcv_lowat", description_tcp_rcv_lowat, additional_constraints_tcp_rcv_lowat, nullptr, 0, false, true}, - {"trace_record_callops", description_trace_record_callops, - additional_constraints_trace_record_callops, nullptr, 0, true, true}, {"unconstrained_max_quota_buffer_size", description_unconstrained_max_quota_buffer_size, additional_constraints_unconstrained_max_quota_buffer_size, nullptr, 0, diff --git a/src/core/lib/experiments/experiments.h b/src/core/lib/experiments/experiments.h index acf99f6e8fb90..b1459ac10879c 100644 --- a/src/core/lib/experiments/experiments.h +++ b/src/core/lib/experiments/experiments.h @@ -62,7 +62,6 @@ inline bool IsBackoffCapInitialAtMaxEnabled() { return true; } #define GRPC_EXPERIMENT_IS_INCLUDED_CALL_TRACER_IN_TRANSPORT inline bool IsCallTracerInTransportEnabled() { return true; } inline bool IsCallv3ClientAuthFilterEnabled() { return false; } -inline bool IsDisableBufferHintOnHighMemoryPressureEnabled() { return false; } inline bool IsEventEngineClientEnabled() { return false; } inline bool IsEventEngineDnsEnabled() { return false; } inline bool IsEventEngineDnsNonClientChannelEnabled() { return false; } @@ -80,7 +79,6 @@ inline bool IsMultipingEnabled() { return false; } #define GRPC_EXPERIMENT_IS_INCLUDED_PICK_FIRST_NEW inline bool IsPickFirstNewEnabled() { return true; } inline bool IsPosixEeSkipGrpcInitEnabled() { return false; } -inline bool IsPrioritizeFinishedRequestsEnabled() { return false; } inline bool IsPromiseBasedHttp2ClientTransportEnabled() { return false; } inline bool IsPromiseBasedHttp2ServerTransportEnabled() { return false; } inline bool IsPromiseBasedInprocTransportEnabled() { return false; } @@ -91,8 +89,6 @@ inline bool IsScheduleCancellationOverWriteEnabled() { return false; } inline bool IsServerListenerEnabled() { return true; } inline bool IsTcpFrameSizeTuningEnabled() { return false; } inline bool IsTcpRcvLowatEnabled() { return false; } -#define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS -inline bool IsTraceRecordCallopsEnabled() { return true; } inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return false; } #elif defined(GPR_WINDOWS) @@ -101,7 +97,6 @@ inline bool IsBackoffCapInitialAtMaxEnabled() { return true; } #define GRPC_EXPERIMENT_IS_INCLUDED_CALL_TRACER_IN_TRANSPORT inline bool IsCallTracerInTransportEnabled() { return true; } inline bool IsCallv3ClientAuthFilterEnabled() { return false; } -inline bool IsDisableBufferHintOnHighMemoryPressureEnabled() { return false; } #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_CLIENT inline bool IsEventEngineClientEnabled() { return true; } #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_DNS @@ -122,7 +117,6 @@ inline bool IsMultipingEnabled() { return false; } #define GRPC_EXPERIMENT_IS_INCLUDED_PICK_FIRST_NEW inline bool IsPickFirstNewEnabled() { return true; } inline bool IsPosixEeSkipGrpcInitEnabled() { return false; } -inline bool IsPrioritizeFinishedRequestsEnabled() { return false; } inline bool IsPromiseBasedHttp2ClientTransportEnabled() { return false; } inline bool IsPromiseBasedHttp2ServerTransportEnabled() { return false; } inline bool IsPromiseBasedInprocTransportEnabled() { return false; } @@ -133,8 +127,6 @@ inline bool IsScheduleCancellationOverWriteEnabled() { return false; } inline bool IsServerListenerEnabled() { return true; } inline bool IsTcpFrameSizeTuningEnabled() { return false; } inline bool IsTcpRcvLowatEnabled() { return false; } -#define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS -inline bool IsTraceRecordCallopsEnabled() { return true; } inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return false; } #else @@ -143,7 +135,6 @@ inline bool IsBackoffCapInitialAtMaxEnabled() { return true; } #define GRPC_EXPERIMENT_IS_INCLUDED_CALL_TRACER_IN_TRANSPORT inline bool IsCallTracerInTransportEnabled() { return true; } inline bool IsCallv3ClientAuthFilterEnabled() { return false; } -inline bool IsDisableBufferHintOnHighMemoryPressureEnabled() { return false; } #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_CLIENT inline bool IsEventEngineClientEnabled() { return true; } #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_DNS @@ -164,7 +155,6 @@ inline bool IsMultipingEnabled() { return false; } #define GRPC_EXPERIMENT_IS_INCLUDED_PICK_FIRST_NEW inline bool IsPickFirstNewEnabled() { return true; } inline bool IsPosixEeSkipGrpcInitEnabled() { return false; } -inline bool IsPrioritizeFinishedRequestsEnabled() { return false; } inline bool IsPromiseBasedHttp2ClientTransportEnabled() { return false; } inline bool IsPromiseBasedHttp2ServerTransportEnabled() { return false; } inline bool IsPromiseBasedInprocTransportEnabled() { return false; } @@ -175,8 +165,6 @@ inline bool IsScheduleCancellationOverWriteEnabled() { return false; } inline bool IsServerListenerEnabled() { return true; } inline bool IsTcpFrameSizeTuningEnabled() { return false; } inline bool IsTcpRcvLowatEnabled() { return false; } -#define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS -inline bool IsTraceRecordCallopsEnabled() { return true; } inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return false; } #endif @@ -185,7 +173,6 @@ enum ExperimentIds { kExperimentIdBackoffCapInitialAtMax, kExperimentIdCallTracerInTransport, kExperimentIdCallv3ClientAuthFilter, - kExperimentIdDisableBufferHintOnHighMemoryPressure, kExperimentIdEventEngineClient, kExperimentIdEventEngineDns, kExperimentIdEventEngineDnsNonClientChannel, @@ -199,7 +186,6 @@ enum ExperimentIds { kExperimentIdMultiping, kExperimentIdPickFirstNew, kExperimentIdPosixEeSkipGrpcInit, - kExperimentIdPrioritizeFinishedRequests, kExperimentIdPromiseBasedHttp2ClientTransport, kExperimentIdPromiseBasedHttp2ServerTransport, kExperimentIdPromiseBasedInprocTransport, @@ -209,7 +195,6 @@ enum ExperimentIds { kExperimentIdServerListener, kExperimentIdTcpFrameSizeTuning, kExperimentIdTcpRcvLowat, - kExperimentIdTraceRecordCallops, kExperimentIdUnconstrainedMaxQuotaBufferSize, kNumExperiments }; @@ -225,11 +210,6 @@ inline bool IsCallTracerInTransportEnabled() { inline bool IsCallv3ClientAuthFilterEnabled() { return IsExperimentEnabled(); } -#define GRPC_EXPERIMENT_IS_INCLUDED_DISABLE_BUFFER_HINT_ON_HIGH_MEMORY_PRESSURE -inline bool IsDisableBufferHintOnHighMemoryPressureEnabled() { - return IsExperimentEnabled< - kExperimentIdDisableBufferHintOnHighMemoryPressure>(); -} #define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_CLIENT inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(); @@ -282,10 +262,6 @@ inline bool IsPickFirstNewEnabled() { inline bool IsPosixEeSkipGrpcInitEnabled() { return IsExperimentEnabled(); } -#define GRPC_EXPERIMENT_IS_INCLUDED_PRIORITIZE_FINISHED_REQUESTS -inline bool IsPrioritizeFinishedRequestsEnabled() { - return IsExperimentEnabled(); -} #define GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_HTTP2_CLIENT_TRANSPORT inline bool IsPromiseBasedHttp2ClientTransportEnabled() { return IsExperimentEnabled(); @@ -322,10 +298,6 @@ inline bool IsTcpFrameSizeTuningEnabled() { inline bool IsTcpRcvLowatEnabled() { return IsExperimentEnabled(); } -#define GRPC_EXPERIMENT_IS_INCLUDED_TRACE_RECORD_CALLOPS -inline bool IsTraceRecordCallopsEnabled() { - return IsExperimentEnabled(); -} #define GRPC_EXPERIMENT_IS_INCLUDED_UNCONSTRAINED_MAX_QUOTA_BUFFER_SIZE inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return IsExperimentEnabled(); diff --git a/src/core/lib/experiments/experiments.yaml b/src/core/lib/experiments/experiments.yaml index 01a32d249a418..32d586f4931d5 100644 --- a/src/core/lib/experiments/experiments.yaml +++ b/src/core/lib/experiments/experiments.yaml @@ -55,11 +55,6 @@ expiry: 2025/06/01 owner: ctiller@google.com test_tags: [core_end2end_test] -- name: disable_buffer_hint_on_high_memory_pressure - description: Disable buffer hint flag parsing in the transport under high memory pressure. - expiry: 2025/03/01 - owner: vigneshbabu@google.com - test_tags: [] - name: event_engine_callback_cq description: Use EventEngine instead of the CallbackAlternativeCQ. expiry: 2025/05/01 @@ -140,12 +135,6 @@ expiry: 2025/03/02 owner: hork@google.com test_tags: ["core_end2end_test", "cpp_end2end_test"] -- name: prioritize_finished_requests - description: Prioritize flushing out finished requests over other in-flight - requests during transport writes. - expiry: 2025/03/01 - owner: vigneshbabu@google.com - test_tags: [] - name: promise_based_http2_client_transport description: Use promises for the http2 client transport. We have kept client and @@ -206,11 +195,6 @@ expiry: 2025/06/01 owner: vigneshbabu@google.com test_tags: ["endpoint_test", "flow_control_test"] -- name: trace_record_callops - description: Enables tracing of call batch initiation and completion. - expiry: 2025/01/30 - owner: vigneshbabu@google.com - test_tags: [] - name: unconstrained_max_quota_buffer_size description: Discard the cap on the max free pool size for one memory allocator expiry: 2025/09/03 diff --git a/src/core/lib/experiments/rollouts.yaml b/src/core/lib/experiments/rollouts.yaml index 47ccae91e0437..3b4d61124b96d 100644 --- a/src/core/lib/experiments/rollouts.yaml +++ b/src/core/lib/experiments/rollouts.yaml @@ -46,8 +46,6 @@ default: true - name: call_v3 default: false -- name: disable_buffer_hint_on_high_memory_pressure - default: false - name: event_engine_callback_cq default: true - name: event_engine_client @@ -82,8 +80,6 @@ default: true - name: posix_ee_skip_grpc_init default: false -- name: prioritize_finished_requests - default: false - name: promise_based_http2_client_transport default: false - name: promise_based_http2_server_transport @@ -100,7 +96,5 @@ default: false - name: tcp_rcv_lowat default: false -- name: trace_record_callops - default: true - name: unconstrained_max_quota_buffer_size default: false diff --git a/test/cpp/ext/filters/census/stats_plugin_end2end_test.cc b/test/cpp/ext/filters/census/stats_plugin_end2end_test.cc index f94349001e3d0..2f20c2bf713a1 100644 --- a/test/cpp/ext/filters/census/stats_plugin_end2end_test.cc +++ b/test/cpp/ext/filters/census/stats_plugin_end2end_test.cc @@ -1110,7 +1110,6 @@ TEST(StatsPluginDeclarationTest, Declarations) { int main(int argc, char** argv) { grpc::testing::TestEnvironment env(&argc, argv); - grpc_core::ForceEnableExperiment("trace_record_callops", true); ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }