Reduce indirection in AbstractRefCounted (#96403)

Today `AbstractRefCounted` holds an `AtomicInteger` which holds the
actual ref count, which is an extra heap object and means that
acquiring/releasing refs always goes through that extra pointer lookup.
We use this utility extensively, on some pretty hot paths, so with this
commit we move to using a primitive `refCount` field with atomic
operations via a `VarHandle`.

Author: DaveCTurner

libs/core/src/main/java/org/elasticsearch/core/AbstractRefCounted.java

@@ -8,17 +8,32 @@
 
 package org.elasticsearch.core;
 
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * A basic {@link RefCounted} implementation that is initialized with a ref count of 1 and calls {@link #closeInternal()} once it reaches
  * a 0 ref count.
  */
 public abstract class AbstractRefCounted implements RefCounted {
+
     public static final String ALREADY_CLOSED_MESSAGE = "already closed, can't increment ref count";
 
-    private final AtomicInteger refCount = new AtomicInteger(1);
+    private static final VarHandle VH_REFCOUNT_FIELD;
+
+    static {
+        try {
+            VH_REFCOUNT_FIELD = MethodHandles.lookup()
+                .in(AbstractRefCounted.class)
+                .findVarHandle(AbstractRefCounted.class, "refCount", int.class);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @SuppressWarnings("FieldMayBeFinal") // updated via VH_REFCOUNT_FIELD (and _only_ via VH_REFCOUNT_FIELD)
+    private volatile int refCount = 1;
 
     protected AbstractRefCounted() {}
 
@@ -32,9 +47,9 @@ public final void incRef() {
     @Override
     public final boolean tryIncRef() {
         do {
-            int i = refCount.get();
+            int i = refCount;
             if (i > 0) {
-                if (refCount.compareAndSet(i, i + 1)) {
+                if (VH_REFCOUNT_FIELD.weakCompareAndSet(this, i, i + 1)) {
                     touch();
                     return true;
                 }
@@ -47,9 +62,9 @@ public final boolean tryIncRef() {
     @Override
     public final boolean decRef() {
         touch();
-        int i = refCount.decrementAndGet();
-        assert i >= 0 : "invalid decRef call: already closed";
-        if (i == 0) {
+        int i = (int) VH_REFCOUNT_FIELD.getAndAdd(this, -1);
+        assert i > 0 : "invalid decRef call: already closed";
+        if (i == 1) {
             try {
                 closeInternal();
             } catch (Exception e) {
@@ -63,7 +78,7 @@ public final boolean decRef() {
 
     @Override
     public final boolean hasReferences() {
-        return refCount.get() > 0;
+        return refCount > 0;
     }
 
     /**
@@ -73,7 +88,7 @@ public final boolean hasReferences() {
     protected void touch() {}
 
     protected void alreadyClosed() {
-        final int currentRefCount = refCount.get();
+        final int currentRefCount = refCount;
         assert currentRefCount == 0 : currentRefCount;
         throw new IllegalStateException(ALREADY_CLOSED_MESSAGE);
     }
@@ -82,7 +97,7 @@ protected void alreadyClosed() {
      * Returns the current reference count.
      */
     public final int refCount() {
-        return this.refCount.get();
+        return refCount;
     }
 
     /**

server/src/main/java/org/elasticsearch/bootstrap/Elasticsearch.java

@@ -24,6 +24,7 @@
 import org.elasticsearch.common.settings.SecureSettings;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.transport.BoundTransportAddress;
+import org.elasticsearch.core.AbstractRefCounted;
 import org.elasticsearch.core.IOUtils;
 import org.elasticsearch.core.SuppressForbidden;
 import org.elasticsearch.env.Environment;
@@ -181,6 +182,8 @@ private static void initPhase2(Bootstrap bootstrap) throws IOException {
         try {
             // ReferenceDocs class does nontrivial static initialization which should always succeed but load it now (before SM) to be sure
             MethodHandles.publicLookup().ensureInitialized(ReferenceDocs.class);
+            // AbstractRefCounted class uses MethodHandles.lookup during initialization, load it now (before SM) to be sure it succeeds
+            MethodHandles.publicLookup().ensureInitialized(AbstractRefCounted.class);
         } catch (IllegalAccessException unexpected) {
             throw new AssertionError(unexpected);
         }