Is there a size limit on a single entry inside Guava cache?

[ScrapCodes]

If so, can we make it configurable?

[lowasser]

There is no specific support for that, other than that the limit on the size of a single entry is the size of the entire cache.

It's easy enough to make there be one, though. Just rewrite your weigher as

(k, v) -> {
  int w = weight(k, v);
  if (w > limit) w = Integer.MAX_VALUE;
  return w;
}

and then set the maxiimum weight to Integer.MAX_VALUE - 1.

[ScrapCodes]

Hi @lowasser

Following is a short code snippet, where I am unable to insert an item more than 1/4 in size of the maximum allowed size(weight).

import com.google.common.cache._
import java.util.Random

object Main extends App {

  def createRandomString(size: Int): String = {
    val random = new Random(System.currentTimeMillis())
    val charArray: Array[Char] = (for ( i <- 0 until size) yield {
      ((Math.abs(random.nextInt()) % 57) +65).asInstanceOf[Char]
    }).toArray[Char]
    new String(charArray)
  }
  val maxSizeInBytes = 2044
  // [[Weigher]].weigh returns Int so we could only cache objects < 2GB
    // instead, the weight is divided by this factor (which is smaller
    // than the size of one [String len]).
    // so it will support objects up to weightscale * 2gb in size.
    val weightScale = 1
    val weigher = new Weigher[Object, String] {
      override def weigh(key: Object, value: String): Int = {
        val estimate = (value.length) / weightScale
        println(s"estimate : $estimate")
        if (estimate > Int.MaxValue) {
          println(s" Too big. Approximating to " +
            s"${Int.MaxValue.toLong * weightScale}.")
          Int.MaxValue
        } else {
          estimate.toInt
        }
      }
    }

  val removalListener = new RemovalListener[Object, String]() {
    override def onRemoval(
      removed: RemovalNotification[Object, String]): Unit = {
      println(
        s"Evicting :${removed.getCause}" +
          " (CacheSize = "
          + maxSizeInBytes + s" bytes) . Size: ${cache.size()}\nStats: ${cache.stats()}")
    }
  }

  // Create a guava cache.
  val cache: Cache[Object, String]  = CacheBuilder.newBuilder()
    .removalListener(removalListener)
    .weigher(weigher)
    .recordStats()
    .maximumWeight(maxSizeInBytes / weightScale)
    .build[Object, String]()

  val largeString = createRandomString(512)
  println(s"pre put Cache Size: ${cache.size()}, stats: ${cache.stats()}," +
    s" adding: ${largeString.length} bytes string.")
  cache.put(new Object(), largeString)
  println(s"post put Cache Size: ${cache.size()}, stats: ${cache.stats()}.")
}

Output

pre put Cache Size: 0, stats: CacheStats{hitCount=0, missCount=0, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=0}, adding: 512 bytes string.
estimate : 512
Evicting :SIZE (CacheSize = 2044 bytes) . Size: 0
Stats: CacheStats{hitCount=0, missCount=0, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=1}
post put Cache Size: 0, stats: CacheStats{hitCount=0, missCount=0, loadSuccessCount=0, loadExceptionCount=0, totalLoadTime=0, evictionCount=1}.

[ScrapCodes]

Guava version used: 14.0.1
Also reproduced with 26.0-jre

[jbduncan]

@ScrapCodes Have you tried version 27.1-jre?

[lowasser]

maximumSize specifies: "Note that the cache may evict an entry before this limit is exceeded."

In the current implementation, this is a normal side effect of concurrencyLevel being greater than one, as the "actual" maximum size of any individual entry becomes maximumSize / concurrencyLevel. There is no guarantee that this will stay the case, however.

[ScrapCodes]

Thanks for explaining, this would mean, that size limit of a single entry in a cache with maximumSize is less than maximumSize /concurrencyLevel. The default value is 4, I hope it is not going to be auto detected, then the same piece of code will behave differently on different machines unless it is explicitly configured.