await(Future future) should immediately return or raise if the future is complete - significant perf improvement

[doctorpangloss]

Version

4.5.11

Context

While upgrading my application to 4.5.11 from 4.4.x, I saw a significant performance regression (almost 3x slower) when removing my usage of the vertx virtual threads incubator and replacing with ThreadingModel.VIRTUAL_THREADS. The root cause was that in my fork of the threads incubator, awaiting a Future will check if the future is complete and return immediately or throw. Upstream, the virtual thread always parks. This is inefficient.

Do you have a reproducer?

This implementation of await exhibits the issue (this is just upstream await):

public static <T> T await(Future<T> fut) {
  return io.vertx.core.Future.await(fut);
}

This does not:

public static <T> T await(Future<T> fut) {
  if (fut == null) {
    throw new IllegalArgumentException("Future cannot be null");
  }
  if (fut.isComplete()) {
    if (fut.succeeded()) {
      return fut.result();
    } else if (fut.cause() != null) {
      throwAsUnchecked(fut.cause());
    } else {
      throw new RuntimeException();
    }
  }
  var ctx = Vertx.currentContext();
  if (ctx == null) {
    try {
      return fut.toCompletionStage().toCompletableFuture().get();
    } catch (InterruptedException | ExecutionException e) {
      throw new RuntimeException(e);
    }
  }
  return io.vertx.core.Future.await(fut);
}

Steps to reproduce

The tests in vert-x3/vertx-virtual-threads-incubator#8 previously investigated and reported the issue.

[re-thc]

This sounds like a good idea for workloads that return quickly. With this change it still suspends if the future isn't completely on the initial check. Did you ever experiment with adding a spin-lock to it? i.e. loop, "yield" and check a few times? Would be interesting to see if it makes a difference.