Replace weak-ref NoopContextScope cache with simple allocation

Benchmarking shows these scopes aren't alive long enough to pay for the caching

Author: mcculls

components/context/src/main/java/datadog/context/NoopContextScope.java

@@ -1,74 +1,24 @@
 package datadog.context;
 
-import java.lang.ref.WeakReference;
-
 /** {@link ContextScope} that has no effect on execution units. */
-final class NoopContextScope extends WeakReference<Context> implements ContextScope {
+final class NoopContextScope implements ContextScope {
   static final ContextScope ROOT_SCOPE = new NoopContextScope(Context.root());
 
-  private static final int CACHE_SIZE = 32; // must be power of 2
-  private static final int SLOT_MASK = CACHE_SIZE - 1;
-  private static final int MAX_HASH_ATTEMPTS = 3;
-
-  /** Bounded cache of no-op scopes to reduce (re)allocations. */
-  private static final NoopContextScope[] cache = new NoopContextScope[CACHE_SIZE];
-
-  @SuppressWarnings({"resource", "StatementWithEmptyBody"})
   static ContextScope create(Context context) {
-    if (context == Context.root()) {
-      return ROOT_SCOPE;
-    }
-    int hash = System.identityHashCode(context);
-    int evictedSlot = -1;
-    // search by repeated hashing; stop when we find an empty slot,
-    // a matching slot, or we exhaust all attempts and re-use a slot
-    for (int i = 1, h = hash; true; i++, h = rehash(h)) {
-      int slot = SLOT_MASK & h;
-      NoopContextScope existing = cache[slot];
-      if (existing != null) {
-        // slot already used
-        Context existingContext = existing.get();
-        if (context == existingContext) {
-          return existing; // match found
-        }
-        if (i < MAX_HASH_ATTEMPTS) {
-          // still more slots to search
-          if (existingContext == null && evictedSlot < 0) {
-            // record first evicted slot for re-use later
-            evictedSlot = slot;
-          }
-          continue; // rehash and try again
-        }
-        // exhausted attempts, pick best slot to re-use
-        if (evictedSlot >= 0) {
-          slot = evictedSlot; // re-use first evicted slot
-        } else if (existingContext == null) {
-          // last hashed slot is itself evicted, re-use it
-        } else {
-          slot = SLOT_MASK & hash; // re-use first hashed slot
-        }
-      }
-      return (cache[slot] = new NoopContextScope(context));
-    }
+    return context == Context.root() ? ROOT_SCOPE : new NoopContextScope(context);
   }
 
+  private final Context context;
+
   private NoopContextScope(Context context) {
-    super(context);
+    this.context = context;
   }
 
   @Override
   public Context context() {
-    Context context = get();
-    // no-op scopes are used when the context is already attached so the reference
-    // value should still be there; if not then we fall back to empty (root) context
-    return context != null ? context : Context.root();
+    return context;
   }
 
   @Override
   public void close() {}
-
-  private static int rehash(int oldHash) {
-    // scatter in both directions using value close to golden ratio
-    return Integer.reverseBytes(oldHash * 0x9e3775cd) * 0x9e3775cd;
-  }
 }

components/context/src/test/java/datadog/context/ContextManagerTest.java

@@ -5,7 +5,6 @@
 import static datadog.context.ContextTest.STRING_KEY;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertSame;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -62,26 +61,23 @@ void testNoopScopeContextReturnsAttachedContext() {
   }
 
   @Test
-  void testNoopScopeCacheHitReturnsSameScope() {
+  void testNoopScopeReturnsCorrectContext() {
     Context context = root().with(STRING_KEY, "value");
     try (ContextScope outer = context.attach()) {
-      // two consecutive noop scopes for the same context should be the same cached instance
       try (ContextScope noop1 = context.attach();
           ContextScope noop2 = context.attach()) {
-        assertSame(noop1, noop2);
+        assertEquals(context, noop1.context());
+        assertEquals(context, noop2.context());
       }
     }
   }
 
   @Test
-  void testNoopScopeCacheHandlesHashCollisions() {
-    // Cycle through enough contexts to overflow the 32-slot cache and exercise
-    // the rehash, collision, and slot-reuse paths inside NoopContextScope.create()
+  void testNoopScopeCorrectContextAcrossManyContexts() {
     for (int i = 0; i < 200; i++) {
       Context ctx = root().with(STRING_KEY, "ctx-" + i);
       try (ContextScope outer = ctx.attach()) {
-        try (ContextScope noop =
-            ctx.attach()) { // same-context attach exercises NoopContextScope.create()
+        try (ContextScope noop = ctx.attach()) {
           assertEquals(ctx, noop.context());
         }
       }