java.lang.Object
net.i2p.util.TryCache<ByteArray>
net.i2p.util.ByteCache
public final class ByteCacheextends TryCache<ByteArray>
Cache the objects frequently used to reduce memory churn. The ByteArray should be held onto as long as the data referenced in it is needed.

For small arrays where the management of valid bytes in ByteArray and prezeroing isn't required, use SimpleByteArray instead.

Heap size control - survey of usage:

+---------------------------------------------------------------------+
|   Size    |   Max   |  MaxMem  | From                               |
+---------------------------------------------------------------------+
|     1K    |    32   |    32K   | tunnel TrivialPreprocessor         |
|     1K    |   512   |   512K   | tunnel FragmentHandler             |
|     1K    |   512   |   512K   | tunnel I2NP TunnelDataMessage      |
|     1K    |   512   |   512K   | tunnel FragmentedMessage           |
|   1572    |    64   |   100K   | UDP InboundMessageState            |
|   1730    |   128   |   216K   | streaming MessageOutputStream      |
|     4K    |    32   |    28K   | I2PTunnelRunner                    |
|     8K    |     8   |    64K   | I2PTunnel HTTPResponseOutputStream |
|    16K    |    16   |   256K   | I2PSnark                           |
|    32K    |     4   |   128K   | SAM StreamSession                  |
|    32K    |    10   |   320K   | SAM v2StreamSession                |
|    32K    |    64   |     2M   | UDP OMS                            |
|    32K    |   128   |     4M   | streaming MessageInputStream       |
|    36K    |    64   |  2.25M   | streaming PacketQueue              |
|    40K    |     8   |   320K   | DataHelper decompress              |
|    64K    |    64   |     4M   | UDP MessageReceiver                |
+---------------------------------------------------------------------+

  • Field Details

    • _log

      private static final Log _log
      The log for the byte cache.

    • _caches

      private static final Map<Integer, ByteCache> _caches
      The caches, by entry size.

    • MIN_CACHE

      private static final int MIN_CACHE
      Max size in bytes of each cache Set to max memory / 128, with a min of 256KB and a max of 8MB.
      See Also:

    • MAX_CACHE_LIMIT

      private static final int MAX_CACHE_LIMIT
      Largest entry size that may be cached.
      See Also:

    • MAX_CACHE

      private static final int MAX_CACHE
      Largest entry size actually allowed.

    • MIN_CACHE_OBJECTS

      private static final int MIN_CACHE_OBJECTS
      Fewest objects a cache holds.
      See Also:

    • CLEANUP_FREQUENCY

      private static final int CLEANUP_FREQUENCY
      How often do we cleanup all caches.
      See Also:

    • EXPIRE_PERIOD

      private static final long EXPIRE_PERIOD
      If the cache size hasn't been exceeded in 90 seconds, cut the cache in half.
      See Also:

    • _allCaches

      private static final List<ByteCache> _allCaches
      Global cleanup task - single timer for all caches.

    • _entrySize

      private final int _entrySize
      The size of the entries in this cache.

  • Constructor Details

    • ByteCache

      private ByteCache(int maxCachedEntries, int entrySize)
      Caches byte arrays of one size.
      Parameters:
      maxCachedEntries - the most arrays to cache
      entrySize - the size of the arrays

  • Method Details

    • cleanup

      private void cleanup()
      Cleanup this specific cache - shrink if underutilized.

    • getInstance

      public static ByteCache getInstance(int cacheSize, int size)
      Shared cache for the given entry size and capacity.
      Parameters:
      cacheSize - the number of entries to hold, trimmed as needed to stay under MAX_CACHE
      size - the byte length of every cached entry, raised to at least 1 and used as the cache key
      Returns:
      the shared cache for that entry size, creating it if needed

    • clearAll

      public static void clearAll()
      Clear everything (memory pressure).

    • resize

      public void resize(int maxCachedEntries)
      Resize the cache to a new capacity.
      Overrides:
      resize in class TryCache<ByteArray>
      Parameters:
      maxCachedEntries - the new maximum number of entries to cache

    • release

      public final void release(ByteArray entry)
      Put this structure back onto the available cache for reuse.
      Overrides:
      release in class TryCache<ByteArray>
      Parameters:
      entry - the value to hand back to the cache for reuse

    • release

      public final void release(ByteArray entry, boolean shouldZero)
      Release the entry back to the cache, optionally zeroing its contents first.
      Parameters:
      entry - the structure being handed back, ignored if null or the wrong size
      shouldZero - true to overwrite the entry's bytes with zeroes before pooling it