Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,6 @@ class SessionList {
// - starting sessions
// - closing sessions
private final Set<SessionHandle> allSessions = new HashSet<>();
private final Set<SessionHandle> inUseSessions = new HashSet<>();

// pool level statistics across all the afes
private final PoolStats poolStats = new PoolStats();
Expand Down Expand Up @@ -119,7 +118,6 @@ public Optional<SessionHandle> checkoutSession(AfeHandle afeHandle) {
handle -> {
poolStats.readyCount--;
poolStats.inUseCount++;
inUseSessions.add(handle);
if (handle.afe.get().sessions.isEmpty()) {
afesWithReadySessions.remove(afeHandle);
}
Expand Down Expand Up @@ -221,7 +219,6 @@ private void releaseToPool() {
AfeHandle afeHandle = this.afe.get();

poolStats.inUseCount--;
inUseSessions.remove(this);

if (!closing && session.getState() == SessionState.READY) {
poolStats.readyCount++;
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -911,7 +911,7 @@ class PendingVRpc<ReqT extends Message, RespT extends Message> implements VRpc<R
private boolean isCancelled = false;
private VRpc<ReqT, RespT> realCall;

private BigtableTimer.Timeout deadlineTimeout;
private volatile BigtableTimer.Timeout deadlineTimeout;

public PendingVRpc(VRpcDescriptor<?, ReqT, RespT> desc) {
this.desc = desc;
Expand All @@ -922,7 +922,7 @@ public PendingVRpc(VRpcDescriptor<?, ReqT, RespT> desc) {
// region. Bounded acquisition on the request hot path; see poolLock.
@SuppressWarnings("GuardedBy")
public void start(ReqT req, VRpcCallContext ctx, VRpcListener<RespT> listener) {
Preconditions.checkState(this.req == null, "request is already started");
Preconditions.checkState(this.ctx == null, "request is already started");
Preconditions.checkNotNull(req, "request can't be null");
Preconditions.checkNotNull(ctx, "ctx can't be null");
Preconditions.checkNotNull(listener, "listener can't be null");
Expand All @@ -940,34 +940,22 @@ public void start(ReqT req, VRpcCallContext ctx, VRpcListener<RespT> listener) {
VRpcResult.createUncommitedError(
Status.UNAVAILABLE.withCause(
new IllegalStateException("SessionPool lock unavailable (pool wedged)")));
ctx.getExecutor()
.execute(
() -> {
if (isCancelled) return;
isCancelled = true;
listener.onClose(result);
});
cancelWithResult(result);
return;
}
try {
if (SessionPoolImpl.this.poolState != PoolState.STARTED) {
VRpcResult result =
VRpcResult.createUncommitedError(
Status.UNAVAILABLE.withCause(new IllegalStateException("SessionPool is closed")));
ctx.getExecutor().execute(() -> listener.onClose(result));
cancelWithResult(result);
return;
}
if (poolSizer.isDisabled()) {
VRpcResult result =
VRpcResult.createRejectedError(
Status.UNAVAILABLE.withDescription("SessionPool configuration disabled"));
ctx.getExecutor()
.execute(
() -> {
if (isCancelled) return;
isCancelled = true;
listener.onClose(result);
});
cancelWithResult(result);
return;
Comment on lines +943 to 959

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

high

Using cancelWithResult(result) for early-fail paths (such as when the pool is wedged, closed, or disabled) introduces a risk of NullPointerException if this.ctx has not been assigned yet.

Furthermore, because these early-fail paths execute before the PendingVRpc is committed to queueing, the PendingVRpc instance is never stored in the pool and is immediately eligible for garbage collection. Therefore, there is no risk of a memory leak, and clearing req and listener references is unnecessary.

It is safer and more efficient to revert to using the parameters ctx and listener directly for these early-fail paths, rather than calling cancelWithResult(result) which accesses and modifies instance fields on a potentially uninitialized or throwaway object.

        ctx.getExecutor()
            .execute(
                () -> {
                  if (isCancelled) return;
                  isCancelled = true;
                  listener.onClose(result);
                });
        return;
      }
      try {
        if (SessionPoolImpl.this.poolState != PoolState.STARTED) {
          VRpcResult result =
              VRpcResult.createUncommitedError(
                  Status.UNAVAILABLE.withCause(new IllegalStateException("SessionPool is closed")));
          ctx.getExecutor().execute(() -> listener.onClose(result));
          return;
        }
        if (poolSizer.isDisabled()) {
          VRpcResult result =
              VRpcResult.createRejectedError(
                  Status.UNAVAILABLE.withDescription("SessionPool configuration disabled"));
          ctx.getExecutor()
              .execute(
                  () -> {
                    if (isCancelled) return;
                    isCancelled = true;
                    listener.onClose(result);
                  });
          return;
        }

}
// Only arm the deadline monitor after we've committed to queueing; otherwise the
Expand Down Expand Up @@ -1013,8 +1001,10 @@ public void cancel(@Nullable String message, @Nullable Throwable cause) {
// region below.
@SuppressWarnings("GuardedBy")
private void cancel(Status status, boolean onlyCancelPendingCall) {
if (deadlineTimeout != null) {
deadlineTimeout.cancel();
BigtableTimer.Timeout timeout = deadlineTimeout;
deadlineTimeout = null;
if (timeout != null) {
timeout.cancel();
}
// The eager removal is only an optimization to skip a wasted session pick in
// tryDrainPendingRpcs.
Expand All @@ -1037,26 +1027,36 @@ private void cancel(Status status, boolean onlyCancelPendingCall) {
() -> {
if (isCancelled) return;
isCancelled = true;
VRpcListener<RespT> pendingListener = listener;
req = null;
listener = null;
if (realCall != null) {
if (!onlyCancelPendingCall) {
realCall.cancel(status.getDescription(), status.getCause());
}
} else {
listener.onClose(VRpcResult.createRejectedError(status));
} else if (pendingListener != null) {
pendingListener.onClose(VRpcResult.createRejectedError(status));
}
});
}

void cancelWithResult(VRpcResult result) {
if (deadlineTimeout != null) {
deadlineTimeout.cancel();
BigtableTimer.Timeout timeout = deadlineTimeout;
deadlineTimeout = null;
if (timeout != null) {
timeout.cancel();
}
ctx.getExecutor()
.execute(
() -> {
if (isCancelled) return;
isCancelled = true;
listener.onClose(result);
VRpcListener<RespT> pendingListener = listener;
req = null;
listener = null;
if (pendingListener != null) {
pendingListener.onClose(result);
}
});
}

Expand All @@ -1077,8 +1077,10 @@ public void requestNext() {
}

private void drainTo(SessionHandle handle) {
if (deadlineTimeout != null) {
deadlineTimeout.cancel();
BigtableTimer.Timeout timeout = deadlineTimeout;
deadlineTimeout = null;
if (timeout != null) {
timeout.cancel();
}
ctx.getExecutor()
.execute(
Expand All @@ -1087,15 +1089,15 @@ private void drainTo(SessionHandle handle) {
SessionPoolImpl.this.onPendingVRpcCancelled(handle);
return;
}
ReqT pendingReq = req;
VRpcListener<RespT> pendingListener = listener;
req = null;
listener = null;
realCall = newRealCall(desc, handle);
realCall.start(req, ctx, listener);
realCall.start(pendingReq, ctx, pendingListener);
});
}

private VRpcListener<RespT> getListener() {
return listener;
}

private BigtableTimer.Timeout monitorDeadline(Deadline deadline) {
// Body runs on backgroundExecutor (off the tick thread). onlyCancelPendingCall=true avoids
// racing with a user cancel that already attached a real call.
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -1448,6 +1448,46 @@ void configUpdateToEmptyClosesSessionsAndScalesBackUpWhenEnabled() throws Except
assertThat(sessionPool.hasSession()).isTrue();
}

@Test
void pendingVRpcClearsReferencesAfterDrainAndCancel() throws Exception {
sessionPool.start(OpenFakeSessionRequest.getDefaultInstance(), new Metadata());

// Create both PendingVRpcs before any session becomes READY so both return PendingVRpc
UnaryResponseFuture<SessionFakeScriptedResponse> drainedFuture = new UnaryResponseFuture<>();
VRpc<SessionFakeScriptedRequest, SessionFakeScriptedResponse> drainedRpc =
sessionPool.newCall(FakeDescriptor.SCRIPTED);
UnaryResponseFuture<SessionFakeScriptedResponse> cancelledFuture = new UnaryResponseFuture<>();
VRpc<SessionFakeScriptedRequest, SessionFakeScriptedResponse> cancelledRpc =
sessionPool.newCall(FakeDescriptor.SCRIPTED);

cancelledRpc.start(
SessionFakeScriptedRequest.getDefaultInstance(),
VRpcCallContext.create(Deadline.after(1, TimeUnit.MINUTES), true, vrpcTracer),
cancelledFuture);
cancelledRpc.cancel("user cancelled", null);

drainedRpc.start(
SessionFakeScriptedRequest.getDefaultInstance(),
VRpcCallContext.create(Deadline.after(1, TimeUnit.MINUTES), true, vrpcTracer),
drainedFuture);
drainedFuture.get(5, TimeUnit.SECONDS);

Field reqField = drainedRpc.getClass().getDeclaredField("req");
Field listenerField = drainedRpc.getClass().getDeclaredField("listener");
Field timeoutField = drainedRpc.getClass().getDeclaredField("deadlineTimeout");
reqField.setAccessible(true);
listenerField.setAccessible(true);
timeoutField.setAccessible(true);

assertThat(reqField.get(drainedRpc)).isNull();
assertThat(listenerField.get(drainedRpc)).isNull();
assertThat(timeoutField.get(drainedRpc)).isNull();

assertThat(reqField.get(cancelledRpc)).isNull();
assertThat(listenerField.get(cancelledRpc)).isNull();
assertThat(timeoutField.get(cancelledRpc)).isNull();
}

private void waitForOpenRequestCount(int minCount, Duration timeout) throws InterruptedException {
long deadline = System.currentTimeMillis() + timeout.toMillis();
while (System.currentTimeMillis() < deadline) {
Expand Down
Loading