diff --git a/java-bigtable/google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizer.java b/java-bigtable/google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizer.java index 3e9d166d9ae0..9c6740e9a339 100644 --- a/java-bigtable/google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizer.java +++ b/java-bigtable/google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizer.java @@ -29,7 +29,7 @@ class PoolSizer { // 50% increase in latency (since that also increases requests-in-flight). private volatile float idlesSessionHeadRoom; private volatile int minIdleSessions; - private volatile int maxIdleSessions; + private volatile int maxSessions; private final PoolStats stats; private final Sized pendingRpcs; @@ -60,12 +60,12 @@ interface Sized { void updateConfig(SessionClientConfiguration.SessionPoolConfiguration poolConfiguration) { this.idlesSessionHeadRoom = poolConfiguration.getHeadroom(); this.minIdleSessions = poolConfiguration.getMinSessionCount(); - this.maxIdleSessions = poolConfiguration.getMaxSessionCount(); + this.maxSessions = poolConfiguration.getMaxSessionCount(); this.pendingVRpcsPerSession = poolConfiguration.getNewSessionQueueLength(); this.disabled = poolConfiguration.equals( SessionClientConfiguration.SessionPoolConfiguration.getDefaultInstance()) - || this.maxIdleSessions <= 0; + || this.maxSessions <= 0; } boolean isDisabled() { @@ -82,9 +82,9 @@ public int getScaleDelta() { int sessionsInUse = effectivePending + stats.getInUseCount(); int unboundedDesiredIdleSessions = (int) Math.ceil(sessionsInUse * idlesSessionHeadRoom); int desiredIdleSessions = - Math.max(Math.min(unboundedDesiredIdleSessions, maxIdleSessions), minIdleSessions); + Math.max(Math.min(unboundedDesiredIdleSessions, maxSessions), minIdleSessions); - int desiredCapacity = sessionsInUse + desiredIdleSessions; + int desiredCapacity = Math.min(sessionsInUse + desiredIdleSessions, maxSessions); int eventualCapacity = stats.getExpectedCapacity(); int immediateCapacity = eventualCapacity - stats.getStartingCount(); diff --git a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizerTest.java b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizerTest.java index a343c7973ce8..f7a6df9a4440 100644 --- a/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizerTest.java +++ b/java-bigtable/google-cloud-bigtable/src/test/java/com/google/cloud/bigtable/data/v2/internal/session/PoolSizerTest.java @@ -31,14 +31,14 @@ class PoolSizerTest { private static final float IDLE_SESSION_HEADROOM_RATIO = 0.5f; private static final int MIN_IDLE_SESSIONS = 5; - private static final int MAX_IDLE_SESSIONS = 400; + private static final int MAX_SESSIONS = 400; private static final int PENDING_RPCS_PER_SESSION = 10; private static final SessionClientConfiguration.SessionPoolConfiguration DEFAULT_CONFIG = SessionClientConfiguration.SessionPoolConfiguration.newBuilder() .setHeadroom(IDLE_SESSION_HEADROOM_RATIO) .setMinSessionCount(MIN_IDLE_SESSIONS) - .setMaxSessionCount(MAX_IDLE_SESSIONS) + .setMaxSessionCount(MAX_SESSIONS) .setNewSessionQueueLength(PENDING_RPCS_PER_SESSION) .build(); @@ -193,7 +193,7 @@ void testEquilibriumWhenStartingWithLoad() { int sessionsNeeded = forPending + stats.getInUseCount(); int desiredIdleSessions = (int) Math.ceil(sessionsNeeded * IDLE_SESSION_HEADROOM_RATIO); desiredIdleSessions = - Math.max(Math.min(desiredIdleSessions, MAX_IDLE_SESSIONS), MIN_IDLE_SESSIONS); + Math.max(Math.min(desiredIdleSessions, MAX_SESSIONS), MIN_IDLE_SESSIONS); int desiredCapacity = sessionsNeeded + desiredIdleSessions; assertThat(sizer.getScaleDelta()) @@ -249,4 +249,26 @@ void testEmptyConfig() { assertThat(sizer.handleGoAway(GoAwayResponse.getDefaultInstance())).isFalse(); assertThat(sizer.handleSessionClose(Status.getDefaultInstance())).isFalse(); } + + @Test + void testDesiredCapacityCappedAtMaxSessions() { + PoolStats stats = new PoolStats(); + AtomicInteger pendingCount = new AtomicInteger(0); + PoolSizer sizer = new PoolSizer(stats, pendingCount::get, DEFAULT_CONFIG); + + // MAX_SESSIONS in use + 2 ready -> immediateCapacity = MAX_SESSIONS + 2. + // Total desiredCapacity is capped at MAX_SESSIONS, so scaleDelta is -2. + stats.getTestHelper().setInUseCount(MAX_SESSIONS); + stats.getTestHelper().setReadyCount(2); + stats.getTestHelper().setExpectedCapacity(MAX_SESSIONS + 2); + assertThat(sizer.getScaleDelta()).isEqualTo(-2); + + // When MAX_SESSIONS are in use and 50 RPCs are queued, scaleDelta must be 0 + // rather than scaling above MAX_SESSIONS. + stats.getTestHelper().setReadyCount(0); + stats.getTestHelper().setExpectedCapacity(MAX_SESSIONS); + pendingCount.set(50); + assertThat(sizer.getScaleDelta()).isEqualTo(0); + assertThat(sizer.handleNewCall()).isFalse(); + } }