Merge github.com:grpc/grpc into grpc_millis

.github/CODEOWNERS

@@ -3,4 +3,5 @@
 # repository as the source of truth for module ownership.
 /**/OWNERS @markdroth @nicolasnoble @ctiller
 /bazel/** @nicolasnoble @dgquintas @ctiller
+/src/compiler/cpp_generator.cc @vjpai
 /src/core/ext/filters/client_channel/** @markdroth @dgquintas @ctiller

CMakeLists.txt

@@ -123,10 +123,8 @@ if("${gRPC_ZLIB_PROVIDER}" STREQUAL "module")
     set(gRPC_INSTALL FALSE)
   endif()
 elseif("${gRPC_ZLIB_PROVIDER}" STREQUAL "package")
-  find_package(ZLIB)
+  find_package(ZLIB REQUIRED)
-  if(TARGET ZLIB::ZLIB)
+  set(_gRPC_ZLIB_LIBRARIES ${ZLIB_LIBRARIES})
-    set(_gRPC_ZLIB_LIBRARIES ZLIB::ZLIB)
-  endif()
   set(_gRPC_FIND_ZLIB "if(NOT ZLIB_FOUND)\n  find_package(ZLIB)\nendif()")
 endif()
 
@@ -145,7 +143,7 @@ if("${gRPC_CARES_PROVIDER}" STREQUAL "module")
     set(gRPC_INSTALL FALSE)
   endif()
 elseif("${gRPC_CARES_PROVIDER}" STREQUAL "package")
-  find_package(c-ares CONFIG)
+  find_package(c-ares REQUIRED CONFIG)
   if(TARGET c-ares::cares)
     set(_gRPC_CARES_LIBRARIES c-ares::cares)
   endif()
@@ -189,7 +187,7 @@ if("${gRPC_PROTOBUF_PROVIDER}" STREQUAL "module")
     set(gRPC_INSTALL FALSE)
   endif()
 elseif("${gRPC_PROTOBUF_PROVIDER}" STREQUAL "package")
-  find_package(Protobuf ${gRPC_PROTOBUF_PACKAGE_TYPE})
+  find_package(Protobuf REQUIRED ${gRPC_PROTOBUF_PACKAGE_TYPE})
   if(Protobuf_FOUND OR PROTOBUF_FOUND)
     if(TARGET protobuf::${_gRPC_PROTOBUF_LIBRARY_NAME})
       set(_gRPC_PROTOBUF_LIBRARIES protobuf::${_gRPC_PROTOBUF_LIBRARY_NAME})
@@ -234,11 +232,9 @@ if("${gRPC_SSL_PROVIDER}" STREQUAL "module")
     set(gRPC_INSTALL FALSE)
   endif()
 elseif("${gRPC_SSL_PROVIDER}" STREQUAL "package")
-  find_package(OpenSSL)
+  find_package(OpenSSL REQUIRED)
-  if(TARGET OpenSSL::SSL)
+  set(_gRPC_SSL_LIBRARIES ${OPENSSL_LIBRARIES})
-    set(_gRPC_SSL_LIBRARIES OpenSSL::SSL)
+  set(_gRPC_FIND_SSL "if(NOT OPENSSL_FOUND)\n  find_package(OpenSSL)\nendif()")
-  endif()
-  set(_gRPC_FIND_SSL "if(NOT OpenSSL_FOUND)\n  find_package(OpenSSL)\nendif()")
 endif()
 
 if("${gRPC_GFLAGS_PROVIDER}" STREQUAL "module")
@@ -831,7 +827,7 @@ endif()
 
 
 target_include_directories(gpr
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -923,7 +919,7 @@ endif()
 
 
 target_include_directories(gpr_test_util
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -1219,7 +1215,7 @@ endif()
 
 
 target_include_directories(grpc
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -1526,7 +1522,7 @@ endif()
 
 
 target_include_directories(grpc_cronet
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -1805,7 +1801,7 @@ endif()
 
 
 target_include_directories(grpc_test_util
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2066,7 +2062,7 @@ endif()
 
 
 target_include_directories(grpc_test_util_unsecure
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2361,7 +2357,7 @@ endif()
 
 
 target_include_directories(grpc_unsecure
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2450,7 +2446,7 @@ endif()
 
 
 target_include_directories(reconnect_server
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2492,7 +2488,7 @@ endif()
 
 
 target_include_directories(test_tcp_server
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2573,7 +2569,7 @@ endif()
 
 
 target_include_directories(grpc++
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -2773,7 +2769,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_core_stats
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3065,7 +3061,7 @@ endif()
 
 
 target_include_directories(grpc++_cronet
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3264,7 +3260,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_error_details
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3329,7 +3325,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_proto_reflection_desc_db
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3390,7 +3386,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_reflection
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3448,7 +3444,7 @@ endif()
 
 
 target_include_directories(grpc++_test_config
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3526,7 +3522,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_test_util
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3664,7 +3660,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc++_test_util_unsecure
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3804,7 +3800,7 @@ endif()
 
 
 target_include_directories(grpc++_unsecure
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -3994,7 +3990,7 @@ endif()
 
 
 target_include_directories(grpc_benchmark
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4053,7 +4049,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(grpc_cli_libs
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4113,7 +4109,7 @@ endif()
 
 
 target_include_directories(grpc_plugin_support
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4191,7 +4187,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(http2_client_main
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4246,7 +4242,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(interop_client_helper
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4316,7 +4312,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(interop_client_main
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4367,7 +4363,7 @@ endif()
 
 
 target_include_directories(interop_server_helper
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4436,7 +4432,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(interop_server_lib
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4487,7 +4483,7 @@ endif()
 
 
 target_include_directories(interop_server_main
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4575,7 +4571,7 @@ protobuf_generate_grpc_cpp(
 )
 
 target_include_directories(qps
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4622,7 +4618,7 @@ endif()
 
 
 target_include_directories(grpc_csharp_ext
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4717,7 +4713,7 @@ endif()
 
 
 target_include_directories(ares
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4755,7 +4751,7 @@ endif()
 
 
 target_include_directories(bad_client_test
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4796,7 +4792,7 @@ endif()
 
 
 target_include_directories(bad_ssl_test_server
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4897,7 +4893,7 @@ endif()
 
 
 target_include_directories(end2end_tests
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src
@@ -4998,7 +4994,7 @@ endif()
 
 
 target_include_directories(end2end_nosec_tests
-  PUBLIC $<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  PUBLIC $<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE ${BORINGSSL_ROOT_DIR}/include
   PRIVATE ${PROTOBUF_ROOT_DIR}/src

examples/cpp/helloworld/CMakeLists.txt

@@ -2,7 +2,11 @@
 cmake_minimum_required(VERSION 2.8)
 
 # Project
-project(HelloWorld CXX)
+project(HelloWorld C CXX)
+
+if(NOT MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+endif()
 
 # Protobuf
 set(protobuf_MODULE_COMPATIBLE TRUE)

include/grpc++/server_builder.h

@@ -136,8 +136,10 @@ class ServerBuilder {
   /// It can be invoked multiple times.
   ///
   /// \param addr_uri The address to try to bind to the server in URI form. If
-  /// the scheme name is omitted, "dns:///" is assumed. Valid values include
+  /// the scheme name is omitted, "dns:///" is assumed. To bind to any address,
-  /// dns:///localhost:1234, / 192.168.1.1:31416, dns:///[::1]:27182, etc.).
+  /// please use IPv6 any, i.e., [::]:<port>, which also accepts IPv4
+  /// connections.  Valid values include dns:///localhost:1234, /
+  /// 192.168.1.1:31416, dns:///[::1]:27182, etc.).
   /// \params creds The credentials associated with the server.
   /// \param selected_port[out] If not `nullptr`, gets populated with the port
   /// number bound to the \a grpc::Server for the corresponding endpoint after

src/compiler/OWNERS

@@ -0,0 +1 @@
+@vjpai cpp_generator.cc

src/core/ext/filters/client_channel/client_channel.c

@@ -1018,13 +1018,11 @@ static void create_subchannel_call_locked(grpc_exec_ctx *exec_ctx,
   GRPC_ERROR_UNREF(error);
 }
 
-static void subchannel_ready_locked(grpc_exec_ctx *exec_ctx,
+// Invoked when a pick is completed, on both success or failure.
-                                    grpc_call_element *elem,
+static void pick_done_locked(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                                    grpc_error *error) {
+                             grpc_error *error) {
   call_data *calld = (call_data *)elem->call_data;
   channel_data *chand = (channel_data *)elem->channel_data;
-  grpc_polling_entity_del_from_pollset_set(exec_ctx, calld->pollent,
-                                           chand->interested_parties);
   if (calld->connected_subchannel == NULL) {
     // Failed to create subchannel.
     GRPC_ERROR_UNREF(calld->error);
@@ -1046,12 +1044,116 @@ static void subchannel_ready_locked(grpc_exec_ctx *exec_ctx,
   GRPC_ERROR_UNREF(error);
 }
 
-/** Return true if subchannel is available immediately (in which case
+// A wrapper around pick_done_locked() that is used in cases where
-    subchannel_ready_locked() should not be called), or false otherwise (in
+// either (a) the pick was deferred pending a resolver result or (b) the
-    which case subchannel_ready_locked() should be called when the subchannel
+// pick was done asynchronously.  Removes the call's polling entity from
-    is available). */
+// chand->interested_parties before invoking pick_done_locked().
-static bool pick_subchannel_locked(grpc_exec_ctx *exec_ctx,
+static void async_pick_done_locked(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem);
+                                   grpc_call_element *elem, grpc_error *error) {
+  channel_data *chand = (channel_data *)elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
+  grpc_polling_entity_del_from_pollset_set(exec_ctx, calld->pollent,
+                                           chand->interested_parties);
+  pick_done_locked(exec_ctx, elem, error);
+}
+
+// Note: This runs under the client_channel combiner, but will NOT be
+// holding the call combiner.
+static void pick_callback_cancel_locked(grpc_exec_ctx *exec_ctx, void *arg,
+                                        grpc_error *error) {
+  grpc_call_element *elem = (grpc_call_element *)arg;
+  channel_data *chand = (channel_data *)elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
+  if (calld->lb_policy != NULL) {
+    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+      gpr_log(GPR_DEBUG, "chand=%p calld=%p: cancelling pick from LB policy %p",
+              chand, calld, calld->lb_policy);
+    }
+    grpc_lb_policy_cancel_pick_locked(exec_ctx, calld->lb_policy,
+                                      &calld->connected_subchannel,
+                                      GRPC_ERROR_REF(error));
+  }
+  GRPC_CALL_STACK_UNREF(exec_ctx, calld->owning_call, "pick_callback_cancel");
+}
+
+// Callback invoked by grpc_lb_policy_pick_locked() for async picks.
+// Unrefs the LB policy and invokes async_pick_done_locked().
+static void pick_callback_done_locked(grpc_exec_ctx *exec_ctx, void *arg,
+                                      grpc_error *error) {
+  grpc_call_element *elem = (grpc_call_element *)arg;
+  channel_data *chand = (channel_data *)elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
+  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed asynchronously",
+            chand, calld);
+  }
+  GPR_ASSERT(calld->lb_policy != NULL);
+  GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
+  calld->lb_policy = NULL;
+  async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
+}
+
+// Takes a ref to chand->lb_policy and calls grpc_lb_policy_pick_locked().
+// If the pick was completed synchronously, unrefs the LB policy and
+// returns true.
+static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
+                                       grpc_call_element *elem) {
+  channel_data *chand = (channel_data *)elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
+  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+    gpr_log(GPR_DEBUG, "chand=%p calld=%p: starting pick on lb_policy=%p",
+            chand, calld, chand->lb_policy);
+  }
+  apply_service_config_to_call_locked(exec_ctx, elem);
+  // If the application explicitly set wait_for_ready, use that.
+  // Otherwise, if the service config specified a value for this
+  // method, use that.
+  uint32_t initial_metadata_flags =
+      calld->initial_metadata_batch->payload->send_initial_metadata
+          .send_initial_metadata_flags;
+  const bool wait_for_ready_set_from_api =
+      initial_metadata_flags &
+      GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
+  const bool wait_for_ready_set_from_service_config =
+      calld->method_params != NULL &&
+      calld->method_params->wait_for_ready != WAIT_FOR_READY_UNSET;
+  if (!wait_for_ready_set_from_api && wait_for_ready_set_from_service_config) {
+    if (calld->method_params->wait_for_ready == WAIT_FOR_READY_TRUE) {
+      initial_metadata_flags |= GRPC_INITIAL_METADATA_WAIT_FOR_READY;
+    } else {
+      initial_metadata_flags &= ~GRPC_INITIAL_METADATA_WAIT_FOR_READY;
+    }
+  }
+  const grpc_lb_policy_pick_args inputs = {
+      calld->initial_metadata_batch->payload->send_initial_metadata
+          .send_initial_metadata,
+      initial_metadata_flags, &calld->lb_token_mdelem};
+  // Keep a ref to the LB policy in calld while the pick is pending.
+  GRPC_LB_POLICY_REF(chand->lb_policy, "pick_subchannel");
+  calld->lb_policy = chand->lb_policy;
+  GRPC_CLOSURE_INIT(&calld->lb_pick_closure, pick_callback_done_locked, elem,
+                    grpc_combiner_scheduler(chand->combiner));
+  const bool pick_done = grpc_lb_policy_pick_locked(
+      exec_ctx, chand->lb_policy, &inputs, &calld->connected_subchannel,
+      calld->subchannel_call_context, NULL, &calld->lb_pick_closure);
+  if (pick_done) {
+    /* synchronous grpc_lb_policy_pick call. Unref the LB policy. */
+    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+      gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed synchronously",
+              chand, calld);
+    }
+    GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
+    calld->lb_policy = NULL;
+  } else {
+    GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback_cancel");
+    grpc_call_combiner_set_notify_on_cancel(
+        exec_ctx, calld->call_combiner,
+        GRPC_CLOSURE_INIT(&calld->lb_pick_cancel_closure,
+                          pick_callback_cancel_locked, elem,
+                          grpc_combiner_scheduler(chand->combiner)));
+  }
+  return pick_done;
+}
 
 typedef struct {
   grpc_call_element *elem;
@@ -1071,17 +1173,17 @@ static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx *exec_ctx,
     gpr_free(args);
     return;
   }
-  args->finished = true;
-  grpc_call_element *elem = args->elem;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
   // If we don't yet have a resolver result, then a closure for
   // pick_after_resolver_result_done_locked() will have been added to
   // chand->waiting_for_resolver_result_closures, and it may not be invoked
   // until after this call has been destroyed.  We mark the operation as
   // finished, so that when pick_after_resolver_result_done_locked()
   // is called, it will be a no-op.  We also immediately invoke
-  // subchannel_ready_locked() to propagate the error back to the caller.
+  // async_pick_done_locked() to propagate the error back to the caller.
+  args->finished = true;
+  grpc_call_element *elem = args->elem;
+  channel_data *chand = (channel_data *)elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
   if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
     gpr_log(GPR_DEBUG,
             "chand=%p calld=%p: cancelling pick waiting for resolver result",
@@ -1089,12 +1191,12 @@ static void pick_after_resolver_result_cancel_locked(grpc_exec_ctx *exec_ctx,
   }
   // Note: Although we are not in the call combiner here, we are
   // basically stealing the call combiner from the pending pick, so
-  // it's safe to call subchannel_ready_locked() here -- we are
+  // it's safe to call async_pick_done_locked() here -- we are
   // essentially calling it here instead of calling it in
   // pick_after_resolver_result_done_locked().
-  subchannel_ready_locked(exec_ctx, elem,
+  async_pick_done_locked(exec_ctx, elem,
-                          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                              "Pick cancelled", &error, 1));
+                             "Pick cancelled", &error, 1));
 }
 
 static void pick_after_resolver_result_done_locked(grpc_exec_ctx *exec_ctx,
@@ -1119,14 +1221,19 @@ static void pick_after_resolver_result_done_locked(grpc_exec_ctx *exec_ctx,
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver failed to return data",
               chand, calld);
     }
-    subchannel_ready_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
+    async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
   } else {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
       gpr_log(GPR_DEBUG, "chand=%p calld=%p: resolver returned, doing pick",
               chand, calld);
     }
-    if (pick_subchannel_locked(exec_ctx, elem)) {
+    if (pick_callback_start_locked(exec_ctx, elem)) {
-      subchannel_ready_locked(exec_ctx, elem, GRPC_ERROR_NONE);
+      // Even if the LB policy returns a result synchronously, we have
+      // already added our polling entity to chand->interested_parties
+      // in order to wait for the resolver result, so we need to
+      // remove it here.  Therefore, we call async_pick_done_locked()
+      // instead of pick_done_locked().
+      async_pick_done_locked(exec_ctx, elem, GRPC_ERROR_NONE);
     }
   }
 }
@@ -1154,154 +1261,38 @@ static void pick_after_resolver_result_start_locked(grpc_exec_ctx *exec_ctx,
                         grpc_combiner_scheduler(chand->combiner)));
 }
 
-// Note: This runs under the client_channel combiner, but will NOT be
+static void start_pick_locked(grpc_exec_ctx *exec_ctx, void *arg,
-// holding the call combiner.
+                              grpc_error *ignored) {
-static void pick_callback_cancel_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                        grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  if (error != GRPC_ERROR_NONE && calld->lb_policy != NULL) {
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
-      gpr_log(GPR_DEBUG, "chand=%p calld=%p: cancelling pick from LB policy %p",
-              chand, calld, calld->lb_policy);
-    }
-    grpc_lb_policy_cancel_pick_locked(exec_ctx, calld->lb_policy,
-                                      &calld->connected_subchannel,
-                                      GRPC_ERROR_REF(error));
-  }
-  GRPC_CALL_STACK_UNREF(exec_ctx, calld->owning_call, "pick_callback_cancel");
-}
-
-// Callback invoked by grpc_lb_policy_pick_locked() for async picks.
-// Unrefs the LB policy and invokes subchannel_ready_locked().
-static void pick_callback_done_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_error *error) {
   grpc_call_element *elem = (grpc_call_element *)arg;
-  channel_data *chand = (channel_data *)elem->channel_data;
   call_data *calld = (call_data *)elem->call_data;
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
-    gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed asynchronously",
-            chand, calld);
-  }
-  GPR_ASSERT(calld->lb_policy != NULL);
-  GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-  calld->lb_policy = NULL;
-  subchannel_ready_locked(exec_ctx, elem, GRPC_ERROR_REF(error));
-}
-
-// Takes a ref to chand->lb_policy and calls grpc_lb_policy_pick_locked().
-// If the pick was completed synchronously, unrefs the LB policy and
-// returns true.
-static bool pick_callback_start_locked(grpc_exec_ctx *exec_ctx,
-                                       grpc_call_element *elem,
-                                       const grpc_lb_policy_pick_args *inputs) {
   channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
+  GPR_ASSERT(calld->connected_subchannel == NULL);
-  if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
+  if (chand->lb_policy != NULL) {
-    gpr_log(GPR_DEBUG, "chand=%p calld=%p: starting pick on lb_policy=%p",
+    // We already have an LB policy, so ask it for a pick.
-            chand, calld, chand->lb_policy);
+    if (pick_callback_start_locked(exec_ctx, elem)) {
-  }
+      // Pick completed synchronously.
-  // Keep a ref to the LB policy in calld while the pick is pending.
+      pick_done_locked(exec_ctx, elem, GRPC_ERROR_NONE);
-  GRPC_LB_POLICY_REF(chand->lb_policy, "pick_subchannel");
+      return;
-  calld->lb_policy = chand->lb_policy;
-  GRPC_CLOSURE_INIT(&calld->lb_pick_closure, pick_callback_done_locked, elem,
-                    grpc_combiner_scheduler(chand->combiner));
-  const bool pick_done = grpc_lb_policy_pick_locked(
-      exec_ctx, chand->lb_policy, inputs, &calld->connected_subchannel,
-      calld->subchannel_call_context, NULL, &calld->lb_pick_closure);
-  if (pick_done) {
-    /* synchronous grpc_lb_policy_pick call. Unref the LB policy. */
-    if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
-      gpr_log(GPR_DEBUG, "chand=%p calld=%p: pick completed synchronously",
-              chand, calld);
     }
-    GRPC_LB_POLICY_UNREF(exec_ctx, calld->lb_policy, "pick_subchannel");
-    calld->lb_policy = NULL;
   } else {
-    GRPC_CALL_STACK_REF(calld->owning_call, "pick_callback_cancel");
+    // We do not yet have an LB policy, so wait for a resolver result.
-    grpc_call_combiner_set_notify_on_cancel(
+    if (chand->resolver == NULL) {
-        exec_ctx, calld->call_combiner,
+      pick_done_locked(exec_ctx, elem,
-        GRPC_CLOSURE_INIT(&calld->lb_pick_cancel_closure,
+                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
-                          pick_callback_cancel_locked, elem,
+      return;
-                          grpc_combiner_scheduler(chand->combiner)));
-  }
-  return pick_done;
-}
-
-static bool pick_subchannel_locked(grpc_exec_ctx *exec_ctx,
-                                   grpc_call_element *elem) {
-  GPR_TIMER_BEGIN("pick_subchannel", 0);
-  channel_data *chand = (channel_data *)elem->channel_data;
-  call_data *calld = (call_data *)elem->call_data;
-  bool pick_done = false;
-  if (chand->lb_policy != NULL) {
-    apply_service_config_to_call_locked(exec_ctx, elem);
-    // If the application explicitly set wait_for_ready, use that.
-    // Otherwise, if the service config specified a value for this
-    // method, use that.
-    uint32_t initial_metadata_flags =
-        calld->initial_metadata_batch->payload->send_initial_metadata
-            .send_initial_metadata_flags;
-    const bool wait_for_ready_set_from_api =
-        initial_metadata_flags &
-        GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET;
-    const bool wait_for_ready_set_from_service_config =
-        calld->method_params != NULL &&
-        calld->method_params->wait_for_ready != WAIT_FOR_READY_UNSET;
-    if (!wait_for_ready_set_from_api &&
-        wait_for_ready_set_from_service_config) {
-      if (calld->method_params->wait_for_ready == WAIT_FOR_READY_TRUE) {
-        initial_metadata_flags |= GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-      } else {
-        initial_metadata_flags &= ~GRPC_INITIAL_METADATA_WAIT_FOR_READY;
-      }
     }
-    const grpc_lb_policy_pick_args inputs = {
-        calld->initial_metadata_batch->payload->send_initial_metadata
-            .send_initial_metadata,
-        initial_metadata_flags, &calld->lb_token_mdelem};
-    pick_done = pick_callback_start_locked(exec_ctx, elem, &inputs);
-  } else if (chand->resolver != NULL) {
     if (!chand->started_resolving) {
       start_resolving_locked(exec_ctx, chand);
     }
     pick_after_resolver_result_start_locked(exec_ctx, elem);
-  } else {
-    subchannel_ready_locked(
-        exec_ctx, elem, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Disconnected"));
-  }
-  GPR_TIMER_END("pick_subchannel", 0);
-  return pick_done;
-}
-
-static void start_pick_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_error *error_ignored) {
-  GPR_TIMER_BEGIN("start_pick_locked", 0);
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *chand = (channel_data *)elem->channel_data;
-  GPR_ASSERT(calld->connected_subchannel == NULL);
-  if (pick_subchannel_locked(exec_ctx, elem)) {
-    // Pick was returned synchronously.
-    if (calld->connected_subchannel == NULL) {
-      GRPC_ERROR_UNREF(calld->error);
-      calld->error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Call dropped by load balancing policy");
-      waiting_for_pick_batches_fail(exec_ctx, elem,
-                                    GRPC_ERROR_REF(calld->error));
-    } else {
-      // Create subchannel call.
-      create_subchannel_call_locked(exec_ctx, elem, GRPC_ERROR_NONE);
-    }
-  } else {
-    // Pick will be done asynchronously.  Add the call's polling entity to
-    // the channel's interested_parties, so that I/O for the resolver
-    // and LB policy can be done under it.
-    grpc_polling_entity_add_to_pollset_set(exec_ctx, calld->pollent,
-                                           chand->interested_parties);
   }
-  GPR_TIMER_END("start_pick_locked", 0);
+  // We need to wait for either a resolver result or for an async result
+  // from the LB policy.  Add the polling entity from call_data to the
+  // channel_data's interested_parties, so that the I/O of the LB policy
+  // and resolver can be done under it.  The polling entity will be
+  // removed in async_pick_done_locked().
+  grpc_polling_entity_add_to_pollset_set(exec_ctx, calld->pollent,
+                                         chand->interested_parties);
 }
 
 static void on_complete(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
@@ -1396,7 +1387,8 @@ static void cc_start_transport_stream_op_batch(
   // combiner to start a pick.
   if (batch->send_initial_metadata) {
     if (GRPC_TRACER_ON(grpc_client_channel_trace)) {
-      gpr_log(GPR_DEBUG, "chand=%p calld=%p: entering combiner", chand, calld);
+      gpr_log(GPR_DEBUG, "chand=%p calld=%p: entering client_channel combiner",
+              chand, calld);
     }
     GRPC_CLOSURE_SCHED(
         exec_ctx,

src/core/ext/transport/chttp2/transport/flow_control.c

@@ -483,7 +483,8 @@ grpc_chttp2_flowctl_action grpc_chttp2_flowctl_get_bdp_action(
     if (grpc_bdp_estimator_get_bw(&tfc->bdp_estimator, &bw_dbl)) {
       // we target the max of BDP or bandwidth in microseconds.
       int32_t frame_size = (int32_t)GPR_CLAMP(
-          GPR_MAX((int32_t)bw_dbl / 1000, bdp), 16384, 16777215);
+          GPR_MAX((int32_t)GPR_CLAMP(bw_dbl, 0, INT_MAX) / 1000, bdp), 16384,
+          16777215);
       grpc_chttp2_flowctl_urgency frame_size_urgency = delta_is_significant(
           tfc, frame_size, GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE);
       if (frame_size_urgency != GRPC_CHTTP2_FLOWCTL_NO_ACTION_NEEDED) {

src/core/lib/debug/stats_data.c

@@ -56,6 +56,8 @@ const char *grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "executor_wakeup_initiated",
     "executor_queue_drained",
     "executor_push_retries",
+    "server_requested_calls",
+    "server_slowpath_requests_queued",
 };
 const char *grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
     "Number of client side calls created by this process",
@@ -98,6 +100,9 @@ const char *grpc_stats_counter_doc[GRPC_STATS_COUNTER_COUNT] = {
     "Number of times an executor queue was drained",
     "Number of times we raced and were forced to retry pushing a closure to "
     "the executor",
+    "How many calls were requested (not necessarily received) by the server",
+    "How many times was the server slow path taken (indicates too few "
+    "outstanding requests)",
 };
 const char *grpc_stats_histogram_name[GRPC_STATS_HISTOGRAM_COUNT] = {
     "tcp_write_size",
@@ -110,6 +115,7 @@ const char *grpc_stats_histogram_name[GRPC_STATS_HISTOGRAM_COUNT] = {
     "http2_send_message_per_write",
     "http2_send_trailing_metadata_per_write",
     "http2_send_flowctl_per_write",
+    "server_cqs_checked",
 };
 const char *grpc_stats_histogram_doc[GRPC_STATS_HISTOGRAM_COUNT] = {
     "Number of bytes offered to each syscall_write",
@@ -122,6 +128,8 @@ const char *grpc_stats_histogram_doc[GRPC_STATS_HISTOGRAM_COUNT] = {
     "Number of streams whose payload was written per TCP write",
     "Number of streams terminated per TCP write",
     "Number of flow control updates written per TCP write",
+    "How many completion queues were checked looking for a CQ that had "
+    "requested the incoming call",
 };
 const int grpc_stats_table_0[65] = {
     0,       1,       2,       3,       4,       6,       8,        11,
@@ -152,6 +160,8 @@ const uint8_t grpc_stats_table_3[102] = {
     23, 24, 24, 24, 25, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 32,
     32, 33, 33, 34, 35, 35, 36, 37, 37, 38, 38, 39, 39, 40, 40, 41, 41,
     42, 42, 43, 44, 44, 45, 46, 46, 47, 48, 48, 49, 49, 50, 50, 51, 51};
+const int grpc_stats_table_4[9] = {0, 1, 2, 4, 7, 13, 23, 39, 64};
+const uint8_t grpc_stats_table_5[9] = {0, 0, 1, 2, 2, 3, 4, 4, 5};
 void grpc_stats_inc_tcp_write_size(grpc_exec_ctx *exec_ctx, int value) {
   value = GPR_CLAMP(value, 0, 16777216);
   if (value < 5) {
@@ -418,16 +428,41 @@ void grpc_stats_inc_http2_send_flowctl_per_write(grpc_exec_ctx *exec_ctx,
                            grpc_stats_histo_find_bucket_slow(
                                (exec_ctx), value, grpc_stats_table_2, 64));
 }
-const int grpc_stats_histo_buckets[10] = {64, 64, 64, 64, 64,
+void grpc_stats_inc_server_cqs_checked(grpc_exec_ctx *exec_ctx, int value) {
-                                          64, 64, 64, 64, 64};
+  value = GPR_CLAMP(value, 0, 64);
-const int grpc_stats_histo_start[10] = {0,   64,  128, 192, 256,
+  if (value < 3) {
-                                        320, 384, 448, 512, 576};
+    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
-const int *const grpc_stats_histo_bucket_boundaries[10] = {
+                             GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, value);
+    return;
+  }
+  union {
+    double dbl;
+    uint64_t uint;
+  } _val, _bkt;
+  _val.dbl = value;
+  if (_val.uint < 4625196817309499392ull) {
+    int bucket =
+        grpc_stats_table_5[((_val.uint - 4613937818241073152ull) >> 51)] + 3;
+    _bkt.dbl = grpc_stats_table_4[bucket];
+    bucket -= (_val.uint < _bkt.uint);
+    GRPC_STATS_INC_HISTOGRAM((exec_ctx),
+                             GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED, bucket);
+    return;
+  }
+  GRPC_STATS_INC_HISTOGRAM((exec_ctx), GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED,
+                           grpc_stats_histo_find_bucket_slow(
+                               (exec_ctx), value, grpc_stats_table_4, 8));
+}
+const int grpc_stats_histo_buckets[11] = {64, 64, 64, 64, 64, 64,
+                                          64, 64, 64, 64, 8};
+const int grpc_stats_histo_start[11] = {0,   64,  128, 192, 256, 320,
+                                        384, 448, 512, 576, 640};
+const int *const grpc_stats_histo_bucket_boundaries[11] = {
     grpc_stats_table_0, grpc_stats_table_2, grpc_stats_table_0,
     grpc_stats_table_0, grpc_stats_table_2, grpc_stats_table_0,
     grpc_stats_table_2, grpc_stats_table_2, grpc_stats_table_2,
-    grpc_stats_table_2};
+    grpc_stats_table_2, grpc_stats_table_4};
-void (*const grpc_stats_inc_histogram[10])(grpc_exec_ctx *exec_ctx, int x) = {
+void (*const grpc_stats_inc_histogram[11])(grpc_exec_ctx *exec_ctx, int x) = {
     grpc_stats_inc_tcp_write_size,
     grpc_stats_inc_tcp_write_iov_size,
     grpc_stats_inc_tcp_read_size,
@@ -437,4 +472,5 @@ void (*const grpc_stats_inc_histogram[10])(grpc_exec_ctx *exec_ctx, int x) = {
     grpc_stats_inc_http2_send_initial_metadata_per_write,
     grpc_stats_inc_http2_send_message_per_write,
     grpc_stats_inc_http2_send_trailing_metadata_per_write,
-    grpc_stats_inc_http2_send_flowctl_per_write};
+    grpc_stats_inc_http2_send_flowctl_per_write,
+    grpc_stats_inc_server_cqs_checked};

src/core/lib/debug/stats_data.h

@@ -58,6 +58,8 @@ typedef enum {
   GRPC_STATS_COUNTER_EXECUTOR_WAKEUP_INITIATED,
   GRPC_STATS_COUNTER_EXECUTOR_QUEUE_DRAINED,
   GRPC_STATS_COUNTER_EXECUTOR_PUSH_RETRIES,
+  GRPC_STATS_COUNTER_SERVER_REQUESTED_CALLS,
+  GRPC_STATS_COUNTER_SERVER_SLOWPATH_REQUESTS_QUEUED,
   GRPC_STATS_COUNTER_COUNT
 } grpc_stats_counters;
 extern const char *grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT];
@@ -73,6 +75,7 @@ typedef enum {
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_MESSAGE_PER_WRITE,
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE,
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE,
+  GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED,
   GRPC_STATS_HISTOGRAM_COUNT
 } grpc_stats_histograms;
 extern const char *grpc_stats_histogram_name[GRPC_STATS_HISTOGRAM_COUNT];
@@ -98,7 +101,9 @@ typedef enum {
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_TRAILING_METADATA_PER_WRITE_BUCKETS = 64,
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE_FIRST_SLOT = 576,
   GRPC_STATS_HISTOGRAM_HTTP2_SEND_FLOWCTL_PER_WRITE_BUCKETS = 64,
-  GRPC_STATS_HISTOGRAM_BUCKETS = 640
+  GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED_FIRST_SLOT = 640,
+  GRPC_STATS_HISTOGRAM_SERVER_CQS_CHECKED_BUCKETS = 8,
+  GRPC_STATS_HISTOGRAM_BUCKETS = 648
 } grpc_stats_histogram_constants;
 #define GRPC_STATS_INC_CLIENT_CALLS_CREATED(exec_ctx) \
   GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_CLIENT_CALLS_CREATED)
@@ -179,6 +184,11 @@ typedef enum {
   GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_EXECUTOR_QUEUE_DRAINED)
 #define GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES(exec_ctx) \
   GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_EXECUTOR_PUSH_RETRIES)
+#define GRPC_STATS_INC_SERVER_REQUESTED_CALLS(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx), GRPC_STATS_COUNTER_SERVER_REQUESTED_CALLS)
+#define GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED(exec_ctx) \
+  GRPC_STATS_INC_COUNTER((exec_ctx),                             \
+                         GRPC_STATS_COUNTER_SERVER_SLOWPATH_REQUESTS_QUEUED)
 #define GRPC_STATS_INC_TCP_WRITE_SIZE(exec_ctx, value) \
   grpc_stats_inc_tcp_write_size((exec_ctx), (int)(value))
 void grpc_stats_inc_tcp_write_size(grpc_exec_ctx *exec_ctx, int x);
@@ -214,10 +224,13 @@ void grpc_stats_inc_http2_send_trailing_metadata_per_write(
   grpc_stats_inc_http2_send_flowctl_per_write((exec_ctx), (int)(value))
 void grpc_stats_inc_http2_send_flowctl_per_write(grpc_exec_ctx *exec_ctx,
                                                  int x);
-extern const int grpc_stats_histo_buckets[10];
+#define GRPC_STATS_INC_SERVER_CQS_CHECKED(exec_ctx, value) \
-extern const int grpc_stats_histo_start[10];
+  grpc_stats_inc_server_cqs_checked((exec_ctx), (int)(value))
-extern const int *const grpc_stats_histo_bucket_boundaries[10];
+void grpc_stats_inc_server_cqs_checked(grpc_exec_ctx *exec_ctx, int x);
-extern void (*const grpc_stats_inc_histogram[10])(grpc_exec_ctx *exec_ctx,
+extern const int grpc_stats_histo_buckets[11];
+extern const int grpc_stats_histo_start[11];
+extern const int *const grpc_stats_histo_bucket_boundaries[11];
+extern void (*const grpc_stats_inc_histogram[11])(grpc_exec_ctx *exec_ctx,
                                                   int x);
 
 #endif /* GRPC_CORE_LIB_DEBUG_STATS_DATA_H */

src/core/lib/debug/stats_data.yaml

@@ -135,3 +135,14 @@
 - counter: executor_push_retries
   doc: Number of times we raced and were forced to retry pushing a closure to
        the executor
+# server
+- counter: server_requested_calls
+  doc: How many calls were requested (not necessarily received) by the server
+- histogram: server_cqs_checked
+  buckets: 8
+  max: 64
+  doc: How many completion queues were checked looking for a CQ that had
+       requested the incoming call
+- counter: server_slowpath_requests_queued
+  doc: How many times was the server slow path taken (indicates too few
+       outstanding requests)

src/core/lib/debug/stats_data_bq_schema.sql

@@ -0,0 +1,33 @@
+client_calls_created_per_iteration:INTEGER,
+server_calls_created_per_iteration:INTEGER,
+syscall_poll_per_iteration:INTEGER,
+syscall_wait_per_iteration:INTEGER,
+histogram_slow_lookups_per_iteration:INTEGER,
+syscall_write_per_iteration:INTEGER,
+syscall_read_per_iteration:INTEGER,
+tcp_backup_pollers_created_per_iteration:INTEGER,
+tcp_backup_poller_polls_per_iteration:INTEGER,
+http2_op_batches_per_iteration:INTEGER,
+http2_op_cancel_per_iteration:INTEGER,
+http2_op_send_initial_metadata_per_iteration:INTEGER,
+http2_op_send_message_per_iteration:INTEGER,
+http2_op_send_trailing_metadata_per_iteration:INTEGER,
+http2_op_recv_initial_metadata_per_iteration:INTEGER,
+http2_op_recv_message_per_iteration:INTEGER,
+http2_op_recv_trailing_metadata_per_iteration:INTEGER,
+http2_settings_writes_per_iteration:INTEGER,
+http2_pings_sent_per_iteration:INTEGER,
+http2_writes_begun_per_iteration:INTEGER,
+http2_writes_offloaded_per_iteration:INTEGER,
+http2_writes_continued_per_iteration:INTEGER,
+http2_partial_writes_per_iteration:INTEGER,
+combiner_locks_initiated_per_iteration:INTEGER,
+combiner_locks_scheduled_items_per_iteration:INTEGER,
+combiner_locks_scheduled_final_items_per_iteration:INTEGER,
+combiner_locks_offloaded_per_iteration:INTEGER,
+executor_scheduled_short_items_per_iteration:INTEGER,
+executor_scheduled_long_items_per_iteration:INTEGER,
+executor_scheduled_to_self_per_iteration:INTEGER,
+executor_wakeup_initiated_per_iteration:INTEGER,
+executor_queue_drained_per_iteration:INTEGER,
+executor_push_retries_per_iteration:INTEGER

src/core/lib/surface/server.c

@@ -29,6 +29,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/connected_channel.h"
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -542,6 +543,7 @@ static void publish_new_rpc(grpc_exec_ctx *exec_ctx, void *arg,
     if (request_id == -1) {
       continue;
     } else {
+      GRPC_STATS_INC_SERVER_CQS_CHECKED(exec_ctx, i);
       gpr_mu_lock(&calld->mu_state);
       calld->state = ACTIVATED;
       gpr_mu_unlock(&calld->mu_state);
@@ -552,6 +554,7 @@ static void publish_new_rpc(grpc_exec_ctx *exec_ctx, void *arg,
   }
 
   /* no cq to take the request found: queue it on the slow list */
+  GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED(exec_ctx);
   gpr_mu_lock(&server->mu_call);
   gpr_mu_lock(&calld->mu_state);
   calld->state = PENDING;
@@ -1434,6 +1437,7 @@ grpc_call_error grpc_server_request_call(
   grpc_call_error error;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   requested_call *rc = (requested_call *)gpr_malloc(sizeof(*rc));
+  GRPC_STATS_INC_SERVER_REQUESTED_CALLS(&exec_ctx);
   GRPC_API_TRACE(
       "grpc_server_request_call("
       "server=%p, call=%p, details=%p, initial_metadata=%p, "
@@ -1480,6 +1484,7 @@ grpc_call_error grpc_server_request_registered_call(
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   requested_call *rc = (requested_call *)gpr_malloc(sizeof(*rc));
   registered_method *rm = (registered_method *)rmp;
+  GRPC_STATS_INC_SERVER_REQUESTED_CALLS(&exec_ctx);
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
       "server=%p, rmp=%p, call=%p, deadline=%p, initial_metadata=%p, "

src/python/grpcio_tests/tests/tests.json

@@ -26,6 +26,8 @@
   "unit._credentials_test.CredentialsTest",
   "unit._cython._cancel_many_calls_test.CancelManyCallsTest",
   "unit._cython._channel_test.ChannelTest",
+  "unit._cython._no_messages_server_completion_queue_per_call_test.Test",
+  "unit._cython._no_messages_single_server_completion_queue_test.Test",
   "unit._cython._read_some_but_not_all_responses_test.ReadSomeButNotAllResponsesTest",
   "unit._cython.cygrpc_test.InsecureServerInsecureClient",
   "unit._cython.cygrpc_test.SecureServerSecureClient",

src/python/grpcio_tests/tests/unit/_cython/_common.py

@@ -0,0 +1,118 @@
+# 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.
+"""Common utilities for tests of the Cython layer of gRPC Python."""
+
+import collections
+import threading
+
+from grpc._cython import cygrpc
+
+RPC_COUNT = 4000
+
+INFINITE_FUTURE = cygrpc.Timespec(float('+inf'))
+EMPTY_FLAGS = 0
+
+INVOCATION_METADATA = cygrpc.Metadata(
+    (cygrpc.Metadatum(b'client-md-key', b'client-md-key'),
+     cygrpc.Metadatum(b'client-md-key-bin', b'\x00\x01' * 3000),))
+
+INITIAL_METADATA = cygrpc.Metadata(
+    (cygrpc.Metadatum(b'server-initial-md-key', b'server-initial-md-value'),
+     cygrpc.Metadatum(b'server-initial-md-key-bin', b'\x00\x02' * 3000),))
+
+TRAILING_METADATA = cygrpc.Metadata(
+    (cygrpc.Metadatum(b'server-trailing-md-key', b'server-trailing-md-value'),
+     cygrpc.Metadatum(b'server-trailing-md-key-bin', b'\x00\x03' * 3000),))
+
+
+class QueueDriver(object):
+
+    def __init__(self, condition, completion_queue):
+        self._condition = condition
+        self._completion_queue = completion_queue
+        self._due = collections.defaultdict(int)
+        self._events = collections.defaultdict(list)
+
+    def add_due(self, tags):
+        if not self._due:
+
+            def in_thread():
+                while True:
+                    event = self._completion_queue.poll()
+                    with self._condition:
+                        self._events[event.tag].append(event)
+                        self._due[event.tag] -= 1
+                        self._condition.notify_all()
+                        if self._due[event.tag] <= 0:
+                            self._due.pop(event.tag)
+                            if not self._due:
+                                return
+
+            thread = threading.Thread(target=in_thread)
+            thread.start()
+        for tag in tags:
+            self._due[tag] += 1
+
+    def event_with_tag(self, tag):
+        with self._condition:
+            while True:
+                if self._events[tag]:
+                    return self._events[tag].pop(0)
+                else:
+                    self._condition.wait()
+
+
+def execute_many_times(behavior):
+    return tuple(behavior() for _ in range(RPC_COUNT))
+
+
+class OperationResult(
+        collections.namedtuple('OperationResult', (
+            'start_batch_result', 'completion_type', 'success',))):
+    pass
+
+
+SUCCESSFUL_OPERATION_RESULT = OperationResult(
+    cygrpc.CallError.ok, cygrpc.CompletionType.operation_complete, True)
+
+
+class RpcTest(object):
+
+    def setUp(self):
+        self.server_completion_queue = cygrpc.CompletionQueue()
+        self.server = cygrpc.Server(cygrpc.ChannelArgs([]))
+        self.server.register_completion_queue(self.server_completion_queue)
+        port = self.server.add_http2_port(b'[::]:0')
+        self.server.start()
+        self.channel = cygrpc.Channel('localhost:{}'.format(port).encode(),
+                                      cygrpc.ChannelArgs([]))
+
+        self._server_shutdown_tag = 'server_shutdown_tag'
+        self.server_condition = threading.Condition()
+        self.server_driver = QueueDriver(self.server_condition,
+                                         self.server_completion_queue)
+        with self.server_condition:
+            self.server_driver.add_due({
+                self._server_shutdown_tag,
+            })
+
+        self.client_condition = threading.Condition()
+        self.client_completion_queue = cygrpc.CompletionQueue()
+        self.client_driver = QueueDriver(self.client_condition,
+                                         self.client_completion_queue)
+
+    def tearDown(self):
+        self.server.shutdown(self.server_completion_queue,
+                             self._server_shutdown_tag)
+        self.server.cancel_all_calls()

src/python/grpcio_tests/tests/unit/_cython/_no_messages_server_completion_queue_per_call_test.py

@@ -0,0 +1,131 @@
+# 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.
+"""Test a corner-case at the level of the Cython API."""
+
+import threading
+import unittest
+
+from grpc._cython import cygrpc
+
+from tests.unit._cython import _common
+
+
+class Test(_common.RpcTest, unittest.TestCase):
+
+    def _do_rpcs(self):
+        server_call_condition = threading.Condition()
+        server_call_completion_queue = cygrpc.CompletionQueue()
+        server_call_driver = _common.QueueDriver(server_call_condition,
+                                                 server_call_completion_queue)
+
+        server_request_call_tag = 'server_request_call_tag'
+        server_send_initial_metadata_tag = 'server_send_initial_metadata_tag'
+        server_complete_rpc_tag = 'server_complete_rpc_tag'
+
+        with self.server_condition:
+            server_request_call_start_batch_result = self.server.request_call(
+                server_call_completion_queue, self.server_completion_queue,
+                server_request_call_tag)
+            self.server_driver.add_due({
+                server_request_call_tag,
+            })
+
+        client_call = self.channel.create_call(
+            None, _common.EMPTY_FLAGS, self.client_completion_queue,
+            b'/twinkies', None, _common.INFINITE_FUTURE)
+        client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag'
+        client_complete_rpc_tag = 'client_complete_rpc_tag'
+        with self.client_condition:
+            client_receive_initial_metadata_start_batch_result = (
+                client_call.start_client_batch(
+                    cygrpc.Operations([
+                        cygrpc.operation_receive_initial_metadata(
+                            _common.EMPTY_FLAGS),
+                    ]), client_receive_initial_metadata_tag))
+            client_complete_rpc_start_batch_result = client_call.start_client_batch(
+                cygrpc.Operations([
+                    cygrpc.operation_send_initial_metadata(
+                        _common.INVOCATION_METADATA, _common.EMPTY_FLAGS),
+                    cygrpc.operation_send_close_from_client(
+                        _common.EMPTY_FLAGS),
+                    cygrpc.operation_receive_status_on_client(
+                        _common.EMPTY_FLAGS),
+                ]), client_complete_rpc_tag)
+            self.client_driver.add_due({
+                client_receive_initial_metadata_tag,
+                client_complete_rpc_tag,
+            })
+
+        server_request_call_event = self.server_driver.event_with_tag(
+            server_request_call_tag)
+
+        with server_call_condition:
+            server_send_initial_metadata_start_batch_result = (
+                server_request_call_event.operation_call.start_server_batch([
+                    cygrpc.operation_send_initial_metadata(
+                        _common.INITIAL_METADATA, _common.EMPTY_FLAGS),
+                ], server_send_initial_metadata_tag))
+            server_call_driver.add_due({
+                server_send_initial_metadata_tag,
+            })
+        server_send_initial_metadata_event = server_call_driver.event_with_tag(
+            server_send_initial_metadata_tag)
+
+        with server_call_condition:
+            server_complete_rpc_start_batch_result = (
+                server_request_call_event.operation_call.start_server_batch([
+                    cygrpc.operation_receive_close_on_server(
+                        _common.EMPTY_FLAGS),
+                    cygrpc.operation_send_status_from_server(
+                        _common.TRAILING_METADATA, cygrpc.StatusCode.ok,
+                        b'test details', _common.EMPTY_FLAGS),
+                ], server_complete_rpc_tag))
+            server_call_driver.add_due({
+                server_complete_rpc_tag,
+            })
+        server_complete_rpc_event = server_call_driver.event_with_tag(
+            server_complete_rpc_tag)
+
+        client_receive_initial_metadata_event = self.client_driver.event_with_tag(
+            client_receive_initial_metadata_tag)
+        client_complete_rpc_event = self.client_driver.event_with_tag(
+            client_complete_rpc_tag)
+
+        return (_common.OperationResult(server_request_call_start_batch_result,
+                                        server_request_call_event.type,
+                                        server_request_call_event.success),
+                _common.OperationResult(
+                    client_receive_initial_metadata_start_batch_result,
+                    client_receive_initial_metadata_event.type,
+                    client_receive_initial_metadata_event.success),
+                _common.OperationResult(client_complete_rpc_start_batch_result,
+                                        client_complete_rpc_event.type,
+                                        client_complete_rpc_event.success),
+                _common.OperationResult(
+                    server_send_initial_metadata_start_batch_result,
+                    server_send_initial_metadata_event.type,
+                    server_send_initial_metadata_event.success),
+                _common.OperationResult(server_complete_rpc_start_batch_result,
+                                        server_complete_rpc_event.type,
+                                        server_complete_rpc_event.success),)
+
+    def test_rpcs(self):
+        expecteds = [(_common.SUCCESSFUL_OPERATION_RESULT,) *
+                     5] * _common.RPC_COUNT
+        actuallys = _common.execute_many_times(self._do_rpcs)
+        self.assertSequenceEqual(expecteds, actuallys)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

src/python/grpcio_tests/tests/unit/_cython/_no_messages_single_server_completion_queue_test.py

@@ -0,0 +1,126 @@
+# 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.
+"""Test a corner-case at the level of the Cython API."""
+
+import threading
+import unittest
+
+from grpc._cython import cygrpc
+
+from tests.unit._cython import _common
+
+
+class Test(_common.RpcTest, unittest.TestCase):
+
+    def _do_rpcs(self):
+        server_request_call_tag = 'server_request_call_tag'
+        server_send_initial_metadata_tag = 'server_send_initial_metadata_tag'
+        server_complete_rpc_tag = 'server_complete_rpc_tag'
+
+        with self.server_condition:
+            server_request_call_start_batch_result = self.server.request_call(
+                self.server_completion_queue, self.server_completion_queue,
+                server_request_call_tag)
+            self.server_driver.add_due({
+                server_request_call_tag,
+            })
+
+        client_call = self.channel.create_call(
+            None, _common.EMPTY_FLAGS, self.client_completion_queue,
+            b'/twinkies', None, _common.INFINITE_FUTURE)
+        client_receive_initial_metadata_tag = 'client_receive_initial_metadata_tag'
+        client_complete_rpc_tag = 'client_complete_rpc_tag'
+        with self.client_condition:
+            client_receive_initial_metadata_start_batch_result = (
+                client_call.start_client_batch(
+                    cygrpc.Operations([
+                        cygrpc.operation_receive_initial_metadata(
+                            _common.EMPTY_FLAGS),
+                    ]), client_receive_initial_metadata_tag))
+            client_complete_rpc_start_batch_result = client_call.start_client_batch(
+                cygrpc.Operations([
+                    cygrpc.operation_send_initial_metadata(
+                        _common.INVOCATION_METADATA, _common.EMPTY_FLAGS),
+                    cygrpc.operation_send_close_from_client(
+                        _common.EMPTY_FLAGS),
+                    cygrpc.operation_receive_status_on_client(
+                        _common.EMPTY_FLAGS),
+                ]), client_complete_rpc_tag)
+            self.client_driver.add_due({
+                client_receive_initial_metadata_tag,
+                client_complete_rpc_tag,
+            })
+
+        server_request_call_event = self.server_driver.event_with_tag(
+            server_request_call_tag)
+
+        with self.server_condition:
+            server_send_initial_metadata_start_batch_result = (
+                server_request_call_event.operation_call.start_server_batch([
+                    cygrpc.operation_send_initial_metadata(
+                        _common.INITIAL_METADATA, _common.EMPTY_FLAGS),
+                ], server_send_initial_metadata_tag))
+            self.server_driver.add_due({
+                server_send_initial_metadata_tag,
+            })
+        server_send_initial_metadata_event = self.server_driver.event_with_tag(
+            server_send_initial_metadata_tag)
+
+        with self.server_condition:
+            server_complete_rpc_start_batch_result = (
+                server_request_call_event.operation_call.start_server_batch([
+                    cygrpc.operation_receive_close_on_server(
+                        _common.EMPTY_FLAGS),
+                    cygrpc.operation_send_status_from_server(
+                        _common.TRAILING_METADATA, cygrpc.StatusCode.ok,
+                        b'test details', _common.EMPTY_FLAGS),
+                ], server_complete_rpc_tag))
+            self.server_driver.add_due({
+                server_complete_rpc_tag,
+            })
+        server_complete_rpc_event = self.server_driver.event_with_tag(
+            server_complete_rpc_tag)
+
+        client_receive_initial_metadata_event = self.client_driver.event_with_tag(
+            client_receive_initial_metadata_tag)
+        client_complete_rpc_event = self.client_driver.event_with_tag(
+            client_complete_rpc_tag)
+
+        return (_common.OperationResult(server_request_call_start_batch_result,
+                                        server_request_call_event.type,
+                                        server_request_call_event.success),
+                _common.OperationResult(
+                    client_receive_initial_metadata_start_batch_result,
+                    client_receive_initial_metadata_event.type,
+                    client_receive_initial_metadata_event.success),
+                _common.OperationResult(client_complete_rpc_start_batch_result,
+                                        client_complete_rpc_event.type,
+                                        client_complete_rpc_event.success),
+                _common.OperationResult(
+                    server_send_initial_metadata_start_batch_result,
+                    server_send_initial_metadata_event.type,
+                    server_send_initial_metadata_event.success),
+                _common.OperationResult(server_complete_rpc_start_batch_result,
+                                        server_complete_rpc_event.type,
+                                        server_complete_rpc_event.success),)
+
+    def test_rpcs(self):
+        expecteds = [(_common.SUCCESSFUL_OPERATION_RESULT,) *
+                     5] * _common.RPC_COUNT
+        actuallys = _common.execute_many_times(self._do_rpcs)
+        self.assertSequenceEqual(expecteds, actuallys)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

templates/CMakeLists.txt.template

@@ -168,10 +168,8 @@
       set(gRPC_INSTALL FALSE)
     endif()
   elseif("<%text>${gRPC_ZLIB_PROVIDER}</%text>" STREQUAL "package")
-    find_package(ZLIB)
+    find_package(ZLIB REQUIRED)
-    if(TARGET ZLIB::ZLIB)
+    set(_gRPC_ZLIB_LIBRARIES <%text>${ZLIB_LIBRARIES}</%text>)
-      set(_gRPC_ZLIB_LIBRARIES ZLIB::ZLIB)
-    endif()
     set(_gRPC_FIND_ZLIB "if(NOT ZLIB_FOUND)\n  find_package(ZLIB)\nendif()")
   endif()
 
@@ -190,7 +188,7 @@
       set(gRPC_INSTALL FALSE)
     endif()
   elseif("<%text>${gRPC_CARES_PROVIDER}</%text>" STREQUAL "package")
-    find_package(c-ares CONFIG)
+    find_package(c-ares REQUIRED CONFIG)
     if(TARGET c-ares::cares)
       set(_gRPC_CARES_LIBRARIES c-ares::cares)
     endif()
@@ -234,7 +232,7 @@
       set(gRPC_INSTALL FALSE)
     endif()
   elseif("<%text>${gRPC_PROTOBUF_PROVIDER}</%text>" STREQUAL "package")
-    find_package(Protobuf <%text>${gRPC_PROTOBUF_PACKAGE_TYPE}</%text>)
+    find_package(Protobuf REQUIRED <%text>${gRPC_PROTOBUF_PACKAGE_TYPE}</%text>)
     if(Protobuf_FOUND OR PROTOBUF_FOUND)
       if(TARGET protobuf::<%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
         set(_gRPC_PROTOBUF_LIBRARIES protobuf::<%text>${_gRPC_PROTOBUF_LIBRARY_NAME}</%text>)
@@ -279,11 +277,9 @@
       set(gRPC_INSTALL FALSE)
     endif()
   elseif("<%text>${gRPC_SSL_PROVIDER}</%text>" STREQUAL "package")
-    find_package(OpenSSL)
+    find_package(OpenSSL REQUIRED)
-    if(TARGET OpenSSL::SSL)
+    set(_gRPC_SSL_LIBRARIES <%text>${OPENSSL_LIBRARIES}</%text>)
-      set(_gRPC_SSL_LIBRARIES OpenSSL::SSL)
+    set(_gRPC_FIND_SSL "if(NOT OPENSSL_FOUND)\n  find_package(OpenSSL)\nendif()")
-    endif()
-    set(_gRPC_FIND_SSL "if(NOT OpenSSL_FOUND)\n  find_package(OpenSSL)\nendif()")
   endif()
 
   if("<%text>${gRPC_GFLAGS_PROVIDER}</%text>" STREQUAL "module")
@@ -515,7 +511,7 @@
   % endfor
 
   target_include_directories(${lib.name}
-    PUBLIC <%text>$<INSTALL_INTERFACE:include> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include></%text>
+    PUBLIC <%text>$<INSTALL_INTERFACE:${gRPC_INSTALL_INCLUDEDIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include></%text>
     PRIVATE <%text>${CMAKE_CURRENT_SOURCE_DIR}</%text>
     PRIVATE <%text>${BORINGSSL_ROOT_DIR}</%text>/include
     PRIVATE <%text>${PROTOBUF_ROOT_DIR}</%text>/src

test/distrib/cpp/run_distrib_test_cmake.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# 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.
+
+set -ex
+
+cd $(dirname $0)/../../..
+
+echo "deb http://ftp.debian.org/debian jessie-backports main" | tee /etc/apt/sources.list.d/jessie-backports.list
+apt-get update
+#apt-get install -t jessie-backports -y libc-ares-dev  # we need specifically version 1.12
+apt-get install -t jessie-backports -y libssl-dev
+
+# Install c-ares
+cd third_party/cares/cares
+git fetch origin
+git checkout cares-1_13_0
+mkdir -p cmake/build
+cd cmake/build
+cmake -DCMAKE_BUILD_TYPE=Release ../..
+make -j4 install
+cd ../../../../..
+rm -rf third_party/cares/cares  # wipe out to prevent influencing the grpc build
+
+# Install zlib
+cd third_party/zlib
+mkdir -p cmake/build
+cd cmake/build
+cmake -DCMAKE_BUILD_TYPE=Release ../..
+make -j4 install
+cd ../../../..
+rm -rf third_party/zlib  # wipe out to prevent influencing the grpc build
+
+# Install protobuf
+cd third_party/protobuf
+mkdir -p cmake/build
+cd cmake/build
+cmake -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release ..
+make -j4 install
+cd ../../../..
+rm -rf third_party/protobuf  # wipe out to prevent influencing the grpc build
+
+# Install gRPC
+mkdir -p cmake/build
+cd cmake/build
+cmake -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DgRPC_PROTOBUF_PROVIDER=package -DgRPC_ZLIB_PROVIDER=package -DgRPC_CARES_PROVIDER=package -DgRPC_SSL_PROVIDER=package -DCMAKE_BUILD_TYPE=Release ../..
+make -j4 install
+cd ../..
+
+# Build helloworld example using cmake
+cd examples/cpp/helloworld
+mkdir -p cmake/build
+cd cmake/build
+cmake ../..
+make
+

tools/buildgen/generate_projects.py

@@ -34,6 +34,7 @@ argp.add_argument('build_files', nargs='+', default=[])
 argp.add_argument('--templates', nargs='+', default=[])
 argp.add_argument('--output_merged', default=None, type=str)
 argp.add_argument('--jobs', '-j', default=multiprocessing.cpu_count(), type=int)
+argp.add_argument('--base', default='.', type=str)
 args = argp.parse_args()
 
 json = args.build_files
@@ -69,7 +70,7 @@ jobs = []
 for template in reversed(sorted(templates)):
   root, f = os.path.split(template)
   if os.path.splitext(f)[1] == '.template':
-    out_dir = '.' + root[len('templates'):]
+    out_dir = args.base + root[len('templates'):]
     out = out_dir + '/' + os.path.splitext(f)[0]
     if not os.path.exists(out_dir):
       os.makedirs(out_dir)

tools/codegen/core/gen_stats_data.py

@@ -313,3 +313,9 @@ with open('src/core/lib/debug/stats_data.c', 'w') as C:
       len(inst_map['Histogram']), ','.join('grpc_stats_table_%d' % x for x in histo_bucket_boundaries))
   print >>C, "void (*const grpc_stats_inc_histogram[%d])(grpc_exec_ctx *exec_ctx, int x) = {%s};" % (
       len(inst_map['Histogram']), ','.join('grpc_stats_inc_%s' % histogram.name.lower() for histogram in inst_map['Histogram']))
+
+with open('src/core/lib/debug/stats_data_bq_schema.sql', 'w') as S:
+  columns = []
+  for counter in inst_map['Counter']:
+    columns.append(('%s_per_iteration' % counter.name, 'INTEGER'))
+  print >>S, ',\n'.join('%s:%s' % x for x in columns)

tools/dockerfile/distribtest/cpp_jessie_x64/Dockerfile

@@ -27,4 +27,6 @@ RUN apt-get update && apt-get install -y \
       pkg-config \
       unzip && apt-get clean
 
+RUN apt-get update && apt-get install -y cmake golang && apt-get clean
+
 CMD ["bash"]

tools/internal_ci/helper_scripts/prepare_build_linux_perf_rc

@@ -0,0 +1,22 @@
+#!/bin/bash
+# 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.
+
+# Source this rc script to prepare the environment for linux perf builds
+
+# Need to increase open files limit and size for perf test
+ulimit -n 32768
+ulimit -c unlimited
+
+git submodule update --init

tools/internal_ci/helper_scripts/prepare_build_linux_rc

@@ -26,6 +26,7 @@ sudo service docker restart
 
 # Populate xdg-cache-home to workaround https://github.com/grpc/grpc/issues/11968
 sudo mkdir -p /tmp/xdg-cache-home
+PYTHONWARNINGS=ignore XDG_CACHE_HOME=/tmp/xdg-cache-home sudo -E pip install setuptools wheel
 PYTHONWARNINGS=ignore XDG_CACHE_HOME=/tmp/xdg-cache-home sudo -E pip install coverage==4.4 pylint==1.6.5
 
 # Download Docker images from DockerHub

tools/internal_ci/linux/grpc_performance_profile_daily.cfg

@@ -0,0 +1,26 @@
+# 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.
+
+# Config file for the internal CI (in protobuf text format)
+
+# Location of the continuous shell script in repository.
+build_file: "grpc/tools/internal_ci/linux/grpc_performance_profile_daily.sh"
+timeout_mins: 1440
+action {
+  define_artifacts {
+    regex: "**"
+    regex: "github/grpc/reports/**"
+  }
+}
+

tools/internal_ci/linux/grpc_performance_profile_daily.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# 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.
+
+set -ex
+
+# Enter the gRPC repo root
+cd $(dirname $0)/../../..
+
+source tools/internal_ci/helper_scripts/prepare_build_linux_perf_rc
+
+CPUS=`python -c 'import multiprocessing; print multiprocessing.cpu_count()'`
+
+make CONFIG=opt memory_profile_test memory_profile_client memory_profile_server -j $CPUS
+bins/opt/memory_profile_test
+bq load microbenchmarks.memory memory_usage.csv
+
+tools/run_tests/run_microbenchmark.py --collect summary --bigquery_upload || FAILED="true"
+
+# kill port_server.py to prevent the build from hanging
+ps aux | grep port_server\\.py | awk '{print $2}' | xargs kill -9
+
+if [ "$FAILED" != "" ]
+then
+  exit 1
+fi

tools/internal_ci/linux/grpc_performance_profile_master.cfg

@@ -0,0 +1,26 @@
+# 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.
+
+# Config file for the internal CI (in protobuf text format)
+
+# Location of the continuous shell script in repository.
+build_file: "grpc/tools/internal_ci/linux/grpc_performance_profile_master.sh"
+timeout_mins: 600
+action {
+  define_artifacts {
+    regex: "**"
+    regex: "github/grpc/reports/**"
+  }
+}
+

tools/internal_ci/linux/grpc_performance_profile_master.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# 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.
+
+set -ex
+
+# Enter the gRPC repo root
+cd $(dirname $0)/../../..
+
+source tools/internal_ci/helper_scripts/prepare_build_linux_perf_rc
+
+tools/jenkins/run_performance_profile_hourly.sh || FAILED="true"
+
+# kill port_server.py to prevent the build from hanging
+ps aux | grep port_server\\.py | awk '{print $2}' | xargs kill -9
+
+if [ "$FAILED" != "" ]
+then
+  exit 1
+fi
+

tools/profiling/microbenchmarks/bm2bq.py

@@ -22,42 +22,15 @@ import sys
 import json
 import csv
 import bm_json
+import json
+import subprocess
+
+columns = []
 
-columns = [
+for row in json.loads(
-  ('jenkins_build', 'integer'),
+    subprocess.check_output([
-  ('jenkins_job', 'string'),
+      'bq','--format=json','show','microbenchmarks.microbenchmarks']))['schema']['fields']:
-  ('date', 'timestamp'),
+  columns.append((row['name'], row['type']))
-  ('cpu_scaling_enabled', 'boolean'),
-  ('num_cpus', 'integer'),
-  ('mhz_per_cpu', 'integer'),
-  ('library_build_type', 'string'),
-  ('name', 'string'),
-  ('fixture', 'string'),
-  ('client_mutator', 'string'),
-  ('server_mutator', 'string'),
-  ('request_size', 'integer'),
-  ('response_size', 'integer'),
-  ('request_count', 'integer'),
-  ('iterations', 'integer'),
-  ('time_unit', 'string'),
-  ('real_time', 'integer'),
-  ('cpu_time', 'integer'),
-  ('bytes_per_second', 'float'),
-  ('allocs_per_iteration', 'float'),
-  ('locks_per_iteration', 'float'),
-  ('writes_per_iteration', 'float'),
-  ('bandwidth_kilobits', 'integer'),
-  ('cli_transport_stalls_per_iteration', 'float'),
-  ('cli_stream_stalls_per_iteration', 'float'),
-  ('svr_transport_stalls_per_iteration', 'float'),
-  ('svr_stream_stalls_per_iteration', 'float'),
-  ('atm_cas_per_iteration', 'float'),
-  ('atm_add_per_iteration', 'float'),
-  ('end_of_stream', 'boolean'),
-  ('header_bytes_per_iteration', 'float'),
-  ('framing_bytes_per_iteration', 'float'),
-  ('nows_per_iteration', 'float'),
-]
 
 SANITIZE = {
   'integer': int,

tools/run_tests/artifacts/distribtest_targets.py

@@ -255,12 +255,13 @@ class PHPDistribTest(object):
 class CppDistribTest(object):
   """Tests Cpp make intall by building examples."""
 
-  def __init__(self, platform, arch, docker_suffix=None):
+  def __init__(self, platform, arch, docker_suffix=None, testcase=None):
-    self.name = 'cpp_%s_%s_%s' % (platform, arch, docker_suffix)
+    self.name = 'cpp_%s_%s_%s_%s' % (platform, arch, docker_suffix, testcase)
     self.platform = platform
     self.arch = arch
     self.docker_suffix = docker_suffix
-    self.labels = ['distribtest', 'cpp', platform, arch, docker_suffix]
+    self.testcase = testcase
+    self.labels = ['distribtest', 'cpp', platform, arch, docker_suffix, testcase]
 
   def pre_build_jobspecs(self):
     return []
@@ -271,7 +272,7 @@ class CppDistribTest(object):
                                    'tools/dockerfile/distribtest/cpp_%s_%s' % (
                                        self.docker_suffix,
                                        self.arch),
-                                   'test/distrib/cpp/run_distrib_test.sh')
+                                   'test/distrib/cpp/run_distrib_test_%s.sh' % self.testcase)
     else:
       raise Exception("Not supported yet.")
 
@@ -281,7 +282,8 @@ class CppDistribTest(object):
 
 def targets():
   """Gets list of supported targets"""
-  return [CppDistribTest('linux', 'x64', 'jessie'),
+  return [CppDistribTest('linux', 'x64', 'jessie', 'routeguide'),
+          CppDistribTest('linux', 'x64', 'jessie', 'cmake'),
           CSharpDistribTest('linux', 'x64', 'wheezy'),
           CSharpDistribTest('linux', 'x64', 'jessie'),
           CSharpDistribTest('linux', 'x86', 'jessie'),

tools/run_tests/run_tests_matrix.py

@@ -29,9 +29,11 @@ from python_utils.filter_pull_request_tests import filter_tests
 _ROOT = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '../..'))
 os.chdir(_ROOT)
 
+_DEFAULT_RUNTESTS_TIMEOUT = 1*60*60
+
 # Set the timeout high to allow enough time for sanitizers and pre-building
 # clang docker.
-_RUNTESTS_TIMEOUT = 4*60*60
+_CPP_RUNTESTS_TIMEOUT = 4*60*60
 
 # Number of jobs assigned to each run_tests.py instance
 _DEFAULT_INNER_JOBS = 2
@@ -51,8 +53,11 @@ def _report_filename_internal_ci(name):
 
 
 def _docker_jobspec(name, runtests_args=[], runtests_envs={},
-                    inner_jobs=_DEFAULT_INNER_JOBS):
+                    inner_jobs=_DEFAULT_INNER_JOBS,
+                    timeout_seconds=None):
   """Run a single instance of run_tests.py in a docker container"""
+  if not timeout_seconds:
+    timeout_seconds = _DEFAULT_RUNTESTS_TIMEOUT
   test_job = jobset.JobSpec(
           cmdline=['python', 'tools/run_tests/run_tests.py',
                    '--use_docker',
@@ -62,15 +67,18 @@ def _docker_jobspec(name, runtests_args=[], runtests_envs={},
                    '--report_suite_name', '%s' % name] + runtests_args,
           environ=runtests_envs,
           shortname='run_tests_%s' % name,
-          timeout_seconds=_RUNTESTS_TIMEOUT)
+          timeout_seconds=timeout_seconds)
   return test_job
 
 
 def _workspace_jobspec(name, runtests_args=[], workspace_name=None,
-                       runtests_envs={}, inner_jobs=_DEFAULT_INNER_JOBS):
+                       runtests_envs={}, inner_jobs=_DEFAULT_INNER_JOBS,
+                       timeout_seconds=None):
   """Run a single instance of run_tests.py in a separate workspace"""
   if not workspace_name:
     workspace_name = 'workspace_%s' % name
+  if not timeout_seconds:
+    timeout_seconds = _DEFAULT_RUNTESTS_TIMEOUT
   env = {'WORKSPACE_NAME': workspace_name}
   env.update(runtests_envs)
   test_job = jobset.JobSpec(
@@ -82,14 +90,15 @@ def _workspace_jobspec(name, runtests_args=[], workspace_name=None,
                    '--report_suite_name', '%s' % name] + runtests_args,
           environ=env,
           shortname='run_tests_%s' % name,
-          timeout_seconds=_RUNTESTS_TIMEOUT)
+          timeout_seconds=timeout_seconds)
   return test_job
 
 
 def _generate_jobs(languages, configs, platforms, iomgr_platform = 'native',
                   arch=None, compiler=None,
                   labels=[], extra_args=[], extra_envs={},
-                  inner_jobs=_DEFAULT_INNER_JOBS):
+                  inner_jobs=_DEFAULT_INNER_JOBS,
+                  timeout_seconds=None):
   result = []
   for language in languages:
     for platform in platforms:
@@ -110,10 +119,12 @@ def _generate_jobs(languages, configs, platforms, iomgr_platform = 'native',
         runtests_args += extra_args
         if platform == 'linux':
           job = _docker_jobspec(name=name, runtests_args=runtests_args,
-                                runtests_envs=extra_envs, inner_jobs=inner_jobs)
+                                runtests_envs=extra_envs, inner_jobs=inner_jobs,
+                                timeout_seconds=timeout_seconds)
         else:
           job = _workspace_jobspec(name=name, runtests_args=runtests_args,
-                                   runtests_envs=extra_envs, inner_jobs=inner_jobs)
+                                   runtests_envs=extra_envs, inner_jobs=inner_jobs,
+                                   timeout_seconds=timeout_seconds)
 
         job.labels = [platform, config, language, iomgr_platform] + labels
         result.append(job)
@@ -136,7 +147,8 @@ def _create_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS):
                              platforms=['linux', 'macos', 'windows'],
                              labels=['basictests', 'corelang'],
                              extra_args=extra_args,
-                             inner_jobs=inner_jobs)
+                             inner_jobs=inner_jobs,
+                             timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
   
   test_jobs += _generate_jobs(languages=['csharp', 'node', 'python'],
                              configs=['dbg', 'opt'],
@@ -151,7 +163,8 @@ def _create_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS):
                               platforms=['linux', 'macos'],
                               labels=['basictests', 'corelang'],
                               extra_args=extra_args,
-                              inner_jobs=inner_jobs)
+                              inner_jobs=inner_jobs,
+                              timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
   
   test_jobs += _generate_jobs(languages=['ruby', 'php'],
                               configs=['dbg', 'opt'],
@@ -174,13 +187,15 @@ def _create_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS):
                               platforms=['linux'],
                               labels=['sanitizers', 'corelang'],
                               extra_args=extra_args,
-                              inner_jobs=inner_jobs)
+                              inner_jobs=inner_jobs,
+                              timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
   test_jobs += _generate_jobs(languages=['c++'],
                               configs=['asan', 'tsan'],
                               platforms=['linux'],
                               labels=['sanitizers', 'corelang'],
                               extra_args=extra_args,
-                              inner_jobs=inner_jobs)
+                              inner_jobs=inner_jobs,
+                              timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
 
   return test_jobs
 
@@ -207,7 +222,8 @@ def _create_portability_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS)
                                 compiler=compiler,
                                 labels=['portability', 'corelang'],
                                 extra_args=extra_args,
-                                inner_jobs=inner_jobs)
+                                inner_jobs=inner_jobs,
+                                timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
 
   # portability C on Windows 64-bit (x86 is the default)
   test_jobs += _generate_jobs(languages=['c'],
@@ -246,10 +262,11 @@ def _create_portability_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS)
                               configs=['dbg'], platforms=['linux'],
                               labels=['portability', 'corelang'],
                               extra_args=extra_args,
-                              extra_envs={'GRPC_DNS_RESOLVER': 'ares'})
+                              extra_envs={'GRPC_DNS_RESOLVER': 'ares'},
+                              timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
 
   # TODO(zyc): Turn on this test after adding c-ares support on windows.
-  # C with the c-ares DNS resolver on Windonws
+  # C with the c-ares DNS resolver on Windows
   # test_jobs += _generate_jobs(languages=['c'],
   #                             configs=['dbg'], platforms=['windows'],
   #                             labels=['portability', 'corelang'],
@@ -292,7 +309,8 @@ def _create_portability_test_jobs(extra_args=[], inner_jobs=_DEFAULT_INNER_JOBS)
                               iomgr_platform='uv',
                               labels=['portability', 'corelang'],
                               extra_args=extra_args,
-                              inner_jobs=inner_jobs)
+                              inner_jobs=inner_jobs,
+                              timeout_seconds=_CPP_RUNTESTS_TIMEOUT)
 
   test_jobs += _generate_jobs(languages=['node'],
                               configs=['dbg'],