Store wait time tracking information as transient

framework/tst/dslabs/framework/testing/ClientWorker.java

@@ -73,15 +73,19 @@ private static class InterRequestTimer implements Timer {}
  @VizIgnore private boolean waitingToSend = false;
  @VizIgnore private Command lastCommand = null;
  @VizIgnore private Result expectedResult = null;
- @VizIgnore private Instant lastSendTime = null;
+ @VizIgnore private transient Instant lastSendTime = null;
 
  // Resulting state
  @Getter @VizIgnore private final List<Command> sentCommands = new ArrayList<>();
  @Getter private final List<Result> results = new ArrayList<>();
  @Getter @VizIgnore private boolean resultsOk = true;
  @Getter @VizIgnore private Pair<Result, Result> expectedAndReceived = null;
- @VizIgnore private Duration maxWaitTime = Duration.ZERO;
- @VizIgnore private Instant maxWaitTimeSendTime = null;
+
+ /**
+ * The longest this client worker has had to wait for a result and the time at which the
+ * corresponding command was sent.
+ */
+ @VizIgnore private transient ImmutablePair<Duration, Instant> maxWait = null;
 
  public <C extends Node & Client> ClientWorker(
  @NonNull C client, @NonNull Workload workload, boolean recordCommandsAndResults) {
@@ -126,27 +130,42 @@ public synchronized void addCommand(String command, String result) {
  * and takes the current time when computing how long it has waited for the most recently sent
  * command.
  *
+ * <p><i>Implementation note:</i> The maximum wait information is stored as a {@code transient}
+ * field. This means that if this {@code ClientWorker} is serialized/deserialized or cloned using
+ * {@link Cloning}, then this information will be lost and the value returned by this method could
+ * be {@code null} (or smaller than it otherwise would have been).
+ *
  * @return the maximum amount of time the client waited, along with the time it sent the command
  * it waited the most time for. Returns {@code null} if it never sent a command.
  */
- public synchronized @Nullable Pair<Duration, Instant> maxWaitTime(@Nullable Instant stopTime) {
- if (!waitingOnResult) {
- if (maxWaitTimeSendTime != null) {
- return ImmutablePair.of(maxWaitTime, maxWaitTimeSendTime);
- }
- return null;
- }
+ public synchronized @Nullable Pair<Duration, Instant> maxWait(@Nullable Instant stopTime) {
  if (stopTime == null) {
  stopTime = Instant.now();
  }
- Duration currentWaitTime = Duration.between(lastSendTime, stopTime);
- if (currentWaitTime.compareTo(maxWaitTime) > 0) {
- return ImmutablePair.of(currentWaitTime, lastSendTime);
+ return maxWaitInternal(stopTime);
+ }
+
+ private ImmutablePair<Duration, Instant> maxWaitInternal(Instant referencePoint) {
+ assert referencePoint != null;
+
+ if (!waitingOnResult) {
+ // If we're not waiting on a result, the reference point is irrelevant. Return the known
+ // value.
+ return maxWait;
+ }
+
+ if (lastSendTime == null) {
+ // We must have never sent a command, or we've lost transient state. We can only return the
+ // current value (which should be null).
+ return maxWait;
  }
- if (maxWaitTimeSendTime != null) {
- return ImmutablePair.of(maxWaitTime, maxWaitTimeSendTime);
+
+ Duration currentWaitTime = Duration.between(lastSendTime, referencePoint);
+ if (maxWait != null && maxWait.getLeft().compareTo(currentWaitTime) >= 0) {
+ return maxWait;
  }
- return null;
+
+ return ImmutablePair.of(currentWaitTime, lastSendTime);
  }
 
  private void sendNextCommandWhilePossible() {
@@ -166,17 +185,14 @@ private void sendNextCommandWhilePossible() {
  return;
  }
 
+ // This call to maxWaitInternal must happen before we update any other tracking state.
+ maxWait = maxWaitInternal(Instant.now());
+
  if (recordCommandsAndResults) {
  sentCommands.add(lastCommand);
  results.add(result);
  }
 
- Duration waitTime = Duration.between(lastSendTime, Instant.now());
- if (waitTime.compareTo(maxWaitTime) > 0) {
- maxWaitTime = waitTime;
- maxWaitTimeSendTime = lastSendTime;
- }
-
  if (workload.hasResults() && !Objects.equals(expectedResult, result)) {
  resultsOk = false;
  if (expectedAndReceived == null) {

framework/tst/dslabs/framework/testing/junit/BaseJUnitTest.java

@@ -228,7 +228,7 @@ protected final void assertMaxWaitTimeLessThan(long allowedMillis) {
  Instant stopTime = runState.stopTime();
  Duration maxWaitTime = Duration.ZERO;
  for (ClientWorker cw : runState.clientWorkers()) {
- var maxWait = cw.maxWaitTime(stopTime);
+ var maxWait = cw.maxWait(stopTime);
  if (maxWait == null) {
  continue;
  }