Making cache more configurable & clean-up

- added ability to configure cache size - for both tag names & values
- factored shared code into Caching static utility class
- added tests for Caching class & size determination logic

Author: dougqh

dd-trace-api/src/main/java/datadog/trace/api/config/GeneralConfig.java

@@ -105,7 +105,8 @@ public final class GeneralConfig {
   public static final String JDK_SOCKET_ENABLED = "jdk.socket.enabled";
 
   public static final String OPTIMIZED_MAP_ENABLED = "optimized.map.enabled";
-  public static final String UTF8_CACHE_ENABLED = "utf8.cache.enabled";
+  public static final String TAG_NAME_UTF8_CACHE_SIZE = "tag.name.utf8.cache.size";
+  public static final String TAG_VALUE_UTF8_CACHE_SIZE = "tag.value.utf8.cache.size";
   public static final String STACK_TRACE_LENGTH_LIMIT = "stack.trace.length.limit";
 
   public static final String SSI_INJECTION_ENABLED = "injection.enabled";

dd-trace-core/src/main/java/datadog/trace/common/writer/ddagent/Caching.java

@@ -0,0 +1,81 @@
+package datadog.trace.common.writer.ddagent;
+
+import java.util.Arrays;
+
+/** Some common static functions used by simple & generational caches */
+final class Caching {
+  private Caching() {}
+
+  /**
+   * Provides the cache size that holds the requestedCapacity
+   *
+   * @param requestedCapacity > 0
+   * @return size >= requestedCapacity
+   */
+  static final int cacheSizeFor(int requestedCapacity) {
+    int pow;
+    for (pow = 1; pow < requestedCapacity; pow *= 2) ;
+    return pow;
+  }
+
+  /** Provides an "adjusted" (e.g. non-zero) hash for the given String */
+  static final int adjHash(String value) {
+    int hash = value.hashCode();
+    return (hash == 0) ? 0xDA7AD06 : hash;
+  }
+
+  /** Resets markers to zero */
+  static final void reset(int[] marks) {
+    Arrays.fill(marks, 0);
+  }
+
+  /**
+   * Changes the mark status of the corresponding slot in the marking array. If there was previously
+   * a matching mark, resets the slot to zero and returns true If there was previously a mismatching
+   * mark, updates the slot and returns false
+   *
+   * <p>A return value of true indicates that the requested value has likely been seen previously
+   * and cache entry should be created.
+   */
+  static final boolean mark(int[] marks, int newAdjHash) {
+    int index = bucketIndex(marks, newAdjHash);
+
+    // This is the 4th iteration of the marking strategy
+    // First version - used a mark entry, but that would prematurely
+    // burn a slot in the cache
+    // Second version - used a mark boolean, that worked well, but
+    // was a overly permissive in allowing the next request to the same slot
+    // to immediately create a CacheEntry
+    // Third version - used a mark hash that to match exactly,
+    // that could lead to access order fights over the cache slot
+    // So this version is a hybrid of 2nd & 3rd, using a bloom filter
+    // that effectively degenerates to a boolean
+
+    // This approach provides a nice balance when there's an A-B-A access pattern
+    // The first A will mark the slot
+    // Then B will mark the slot with A | B
+    // Then either A or B can claim and reset the slot
+
+    int priorMarkHash = marks[index];
+    boolean match = ((priorMarkHash & newAdjHash) == newAdjHash);
+    if (match) {
+      marks[index] = 0;
+    } else {
+      marks[index] = priorMarkHash | newAdjHash;
+    }
+    return match;
+  }
+
+  /** Provides the corresponding index into the marking array */
+  static final int bucketIndex(int[] marks, int adjHash) {
+    return adjHash & (marks.length - 1);
+  }
+
+  /**
+   * Provides the corresponding index into an entry array Assumes that array size was determined by
+   * using {@Caching#cacheSizeFor}
+   */
+  static final <E> int bucketIndex(E[] entries, int adjHash) {
+    return adjHash & (entries.length - 1);
+  }
+}

dd-trace-core/src/main/java/datadog/trace/common/writer/ddagent/GenerationalUtf8Cache.java

@@ -3,7 +3,6 @@
 import datadog.communication.serialization.EncodingCache;
 import datadog.trace.common.writer.ddagent.SimpleUtf8Cache.CacheEntry;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 
 /**
  * 2-level generational cache of UTF8 values - primarily intended to be used for tag values
@@ -65,6 +64,9 @@
  * provide better cache utilization.
  */
 public final class GenerationalUtf8Cache implements EncodingCache {
+  static final int MAX_EDEN_CAPACITY = 512;
+  static final int MAX_TENURED_CAPACITY = 1024;
+
   private static final int MAX_EDEN_PROBES = 4;
   private static final int MAX_TENURED_PROBES = 8;
 
@@ -75,6 +77,9 @@ public final class GenerationalUtf8Cache implements EncodingCache {
   private static final double PURGE_THRESHOLD = 0.25D;
   private static final double PROMOTION_THRESHOLD_ADJ_FACTOR = 1.5;
 
+  private static final double EDEN_PROPORTION = 1D / 3D;
+  private static final double TENURED_PROPORTION = 1 - EDEN_PROPORTION;
+
   private static final int MAX_ENTRY_LEN = 256;
 
   private final CacheEntry[] edenEntries;
@@ -92,15 +97,40 @@ public final class GenerationalUtf8Cache implements EncodingCache {
   int edenEvictions = 0;
   int tenuredEvictions = 0;
 
-  public GenerationalUtf8Cache() {
+  public GenerationalUtf8Cache(int capacity) {
     this.accessTimeMs = System.currentTimeMillis();
 
+    int edenCapacity = (int) (capacity * EDEN_PROPORTION);
+    int edenSize = Caching.cacheSizeFor(Math.min(edenCapacity, MAX_EDEN_CAPACITY));
+
     // These sizes must be powers of 2
-    this.edenEntries = new CacheEntry[64];
-    this.edenMarkers = new int[64];
+    this.edenEntries = new CacheEntry[edenSize];
+    this.edenMarkers = new int[edenSize];
+
+    int tenuredCapacity = (int) (capacity * TENURED_PROPORTION);
+    int tenuredSize = Caching.cacheSizeFor(Math.min(tenuredCapacity, MAX_TENURED_CAPACITY));
 
     // The size must be a power of 2
-    this.tenuredEntries = new CacheEntry[128];
+    this.tenuredEntries = new CacheEntry[tenuredSize];
+  }
+
+  public GenerationalUtf8Cache(int edenCapacity, int tenuredCapacity) {
+    this.accessTimeMs = System.currentTimeMillis();
+
+    int edenSize = Caching.cacheSizeFor(Math.min(tenuredCapacity, MAX_EDEN_CAPACITY));
+    this.edenEntries = new CacheEntry[edenSize];
+    this.edenMarkers = new int[edenSize];
+
+    int tenuredSize = Caching.cacheSizeFor(Math.min(tenuredCapacity, MAX_TENURED_CAPACITY));
+    this.tenuredEntries = new CacheEntry[tenuredSize];
+  }
+
+  public int edenCapacity() {
+    return this.edenEntries.length;
+  }
+
+  public int tenuredCapacity() {
+    return this.tenuredEntries.length;
   }
 
   /** Updates access time used @link {@link #getUtf8(String, String)} to the provided value */
@@ -129,25 +159,9 @@ public synchronized void recalibrate() {
   public void recalibrate(long accessTimeMs) {
     this.accessTimeMs = accessTimeMs;
 
-    CacheEntry[] edenEntries = this.edenEntries;
-    for (int i = 0; i < edenEntries.length; ++i) {
-      CacheEntry entry = edenEntries[i];
-      if (entry == null) continue;
-
-      boolean purge = entry.decay();
-      if (purge) edenEntries[i] = null;
-    }
-
-    Arrays.fill(this.edenMarkers, 0);
-
-    CacheEntry[] tenuredEntries = this.tenuredEntries;
-    for (int i = 0; i < tenuredEntries.length; ++i) {
-      CacheEntry entry = tenuredEntries[i];
-      if (entry == null) continue;
-
-      boolean purge = entry.decay();
-      if (purge) tenuredEntries[i] = null;
-    }
+    recalibrate(this.edenEntries);
+    Caching.reset(this.edenMarkers);
+    recalibrate(this.tenuredEntries);
 
     int totalPromotions = this.promotions + this.earlyPromotions;
     if (totalPromotions == 0 && this.promotionThreshold >= MIN_PROMOTION_TRESHOLD) {
@@ -164,6 +178,16 @@ public void recalibrate(long accessTimeMs) {
     this.tenuredEvictions = 0;
   }
 
+  static final void recalibrate(CacheEntry[] entries) {
+    for (int i = 0; i < entries.length; ++i) {
+      CacheEntry entry = entries[i];
+      if (entry == null) continue;
+
+      boolean purge = entry.decay();
+      if (purge) entries[i] = null;
+    }
+  }
+
   @Override
   public byte[] encode(CharSequence charSeq) {
     if (charSeq instanceof String) {
@@ -186,7 +210,7 @@ public final byte[] getUtf8(String value) {
   public final byte[] getUtf8(String value, long accessTimeMs) {
     if (value.length() > MAX_ENTRY_LEN) return CacheEntry.utf8(value);
 
-    int adjHash = CacheEntry.adjHash(value);
+    int adjHash = Caching.adjHash(value);
     long lookupTimeMs = this.accessTimeMs;
 
     CacheEntry[] tenuredEntries = this.tenuredEntries;
@@ -220,7 +244,7 @@ public final byte[] getUtf8(String value, long accessTimeMs) {
       return edenEntry.utf8();
     }
 
-    boolean wasMarked = mark(this.edenMarkers, adjHash);
+    boolean wasMarked = Caching.mark(this.edenMarkers, adjHash);
 
     // If slot isn't marked, this is likely the first request
     // Don't create an entry yet
@@ -265,7 +289,7 @@ public final byte[] getUtf8(String value, long accessTimeMs) {
   }
 
   static final int findAvailableIndex(CacheEntry[] entries, int numProbes, int newAdjHash) {
-    int initialBucketIndex = initialBucketIndex(entries, newAdjHash);
+    int initialBucketIndex = Caching.bucketIndex(entries, newAdjHash);
     for (int probe = 0, index = initialBucketIndex; probe < numProbes; ++probe, ++index) {
       if (index >= entries.length) index = 0;
 
@@ -280,7 +304,7 @@ static final int findFirstAvailableOrMfuIndex(
     double mfuScore = Double.MIN_VALUE;
     int mfuIndex = -1;
 
-    int initialBucketIndex = initialBucketIndex(entries, newAdjHash);
+    int initialBucketIndex = Caching.bucketIndex(entries, newAdjHash);
     for (int probe = 0, index = initialBucketIndex; probe < numProbes; ++probe, ++index) {
       if (index >= entries.length) index = 0;
 
@@ -296,37 +320,8 @@ static final int findFirstAvailableOrMfuIndex(
     return mfuIndex;
   }
 
-  static final boolean mark(int[] marks, int newAdjHash) {
-    int index = initialBucketIndex(marks, newAdjHash);
-
-    // This is the 4th iteration of the marking strategy
-    // First version - used a mark entry, but that would prematurely
-    // burn a slot in the cache
-    // Second version - used a mark boolean, that worked well, but
-    // was a overly permissive in allowing the next request to the same slot
-    // to immediately create a CacheEntry
-    // Third version - used a mark hash that to match exactly,
-    // that could lead to access order fights over the cache slot
-    // So this version is a hybrid of 2nd & 3rd, using a bloom filter
-    // that effectively degenerates to a boolean
-
-    // This approach provides a nice balance when there's an A-B-A access pattern
-    // The first A will mark the slot
-    // Then B will mark the slot with A | B
-    // Then either A or B can claim and reset the slot
-
-    int priorMarkHash = marks[index];
-    boolean match = ((priorMarkHash & newAdjHash) == newAdjHash);
-    if (match) {
-      marks[index] = 0;
-    } else {
-      marks[index] = priorMarkHash | newAdjHash;
-    }
-    return match;
-  }
-
   static final boolean lfuInsert(CacheEntry[] entries, int numProbes, CacheEntry newEntry) {
-    int initialBucketIndex = initialBucketIndex(entries, newEntry.adjHash());
+    int initialBucketIndex = Caching.bucketIndex(entries, newEntry.adjHash());
 
     // initial scan to see if there's an empty slot or marker entry is already present
     double lowestScore = Double.MAX_VALUE;
@@ -353,7 +348,7 @@ static final boolean lfuInsert(CacheEntry[] entries, int numProbes, CacheEntry n
   }
 
   static final boolean lruInsert(CacheEntry[] entries, int numProbes, CacheEntry newEntry) {
-    int initialBucketIndex = initialBucketIndex(entries, newEntry.adjHash());
+    int initialBucketIndex = Caching.bucketIndex(entries, newEntry.adjHash());
 
     // initial scan to see if there's an empty slot or entry is already present
     long lowestUsedMs = Long.MAX_VALUE;
@@ -378,17 +373,9 @@ static final boolean lruInsert(CacheEntry[] entries, int numProbes, CacheEntry n
     return true;
   }
 
-  static final int initialBucketIndex(CacheEntry[] entries, int adjHash) {
-    return adjHash & (entries.length - 1);
-  }
-
-  static final int initialBucketIndex(int[] marks, int adjHash) {
-    return adjHash & (marks.length - 1);
-  }
-
   static final int lookupEntryIndex(
       CacheEntry[] entries, int numProbes, int adjHash, String value) {
-    int initialBucketIndex = initialBucketIndex(entries, adjHash);
+    int initialBucketIndex = Caching.bucketIndex(entries, adjHash);
     for (int probe = 0, index = initialBucketIndex; probe < numProbes; ++probe, ++index) {
       if (index >= entries.length) index = 0;
 
@@ -456,11 +443,6 @@ boolean isPurgeable() {
       return (this.score < PURGE_THRESHOLD);
     }
 
-    static final int adjHash(String value) {
-      int hash = value.hashCode();
-      return (hash == 0) ? 0xDA7AD06 : hash;
-    }
-
     static final byte[] utf8(String value) {
       return value.getBytes(StandardCharsets.UTF_8);
     }