fix(spanner): drop sticky AFFINITY_KEY for static gRPC-GCP pool

The static-pool path bounded the affinity key to (-numChannels..numChannels)
distinct values. Under a high-concurrency cold start, all keys race through
GcpManagedChannel.pickLeastBusyChannel before any caller's start() has
incremented activeStreamsCount, so they all tie to channelRefs[0] and bind
there permanently. The result is most RPCs route through a single HTTP/2
connection and queue at MAX_CONCURRENT_STREAMS (~100), capping per-client
throughput. Regression became default-path behavior in 6.105.0 (#4239).

With multiplexed sessions there is no per-transaction locality benefit from
sticky channel affinity. Dropping the key for the static-pool case makes
GcpManagedChannel.getChannelRef(null) do a fresh per-call least-busy pick
with no sticky bind, which self-corrects and matches the dynamic-pool /
disableGrpcGcpExtension() throughput curve.

Author: akash329d

java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java

@@ -2275,30 +2275,32 @@ <ReqT, RespT> GrpcCallContext newCallContext(
     Long affinity = options == null ? null : Option.CHANNEL_HINT.getLong(options);
     if (affinity != null) {
       if (this.isGrpcGcpExtensionEnabled) {
-        // Set channel affinity in gRPC-GCP.
-        String affinityKey;
         if (this.isDynamicChannelPoolEnabled) {
           // When dynamic channel pooling is enabled, we use the raw affinity value as the key.
           // This allows grpc-gcp to use round-robin for new keys, enabling new channels
           // (created during scale-up) to receive requests. The affinity key lifetime setting
           // ensures the affinity map doesn't grow unbounded.
-          affinityKey = String.valueOf(affinity);
-        } else {
-          // When DCP is disabled, compute bounded channel hint to prevent
-          // gRPC-GCP affinity map from getting unbounded.
-          int boundedChannelHint = affinity.intValue() % this.numChannels;
-          affinityKey = String.valueOf(boundedChannelHint);
-        }
-        context =
-            context.withCallOptions(
-                context.getCallOptions().withOption(GcpManagedChannel.AFFINITY_KEY, affinityKey));
-        // Check if the caller wants to unbind the affinity key after this call completes.
-        Boolean unbind = Option.UNBIND_CHANNEL_HINT.get(options);
-        if (Boolean.TRUE.equals(unbind)) {
+          String affinityKey = String.valueOf(affinity);
           context =
               context.withCallOptions(
-                  context.getCallOptions().withOption(GcpManagedChannel.UNBIND_AFFINITY_KEY, true));
+                  context.getCallOptions().withOption(GcpManagedChannel.AFFINITY_KEY, affinityKey));
+          // Check if the caller wants to unbind the affinity key after this call completes.
+          Boolean unbind = Option.UNBIND_CHANNEL_HINT.get(options);
+          if (Boolean.TRUE.equals(unbind)) {
+            context =
+                context.withCallOptions(
+                    context
+                        .getCallOptions()
+                        .withOption(GcpManagedChannel.UNBIND_AFFINITY_KEY, true));
+          }
         }
+        // Static pool: do not set AFFINITY_KEY. Multiplexed sessions get no locality
+        // benefit from sticky per-transaction channel affinity, and bounding the key
+        // to numChannels distinct values caused those keys to permanently bind to a
+        // single channel under concurrent first-use (GcpManagedChannel.pickLeastBusyChannel
+        // reads activeStreamsCount before any caller's start() has incremented it, so a
+        // warmup burst all ties to channelRefs[0]). With no key, getChannelRef(null) does
+        // a fresh per-call least-busy pick with no sticky bind, which self-corrects.
       } else {
         // Set channel affinity in GAX.
         context = context.withChannelAffinity(affinity.intValue());