private static synchronized Cache<String, SearchArgument> initializeAndGetSargsCache(Configuration conf) { if (sargsCache == null) { sargsCache = CacheBuilder.newBuilder() .weigher((String key, SearchArgument value) -> key.length()) .maximumWeight( HiveConf.getIntVar(conf, HiveConf.ConfVars.HIVE_IO_SARG_CACHE_MAX_WEIGHT_MB) * 1024 *1024 ) .build(); // Can't use CacheLoader because SearchArguments may be built either from Kryo strings, // or from expressions. } return sargsCache; }
@GwtIncompatible // maximumWeight public void testMaximumSize_andWeight() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().maximumSize(16); try { builder.maximumWeight(16); fail(); } catch (IllegalStateException expected) { } }
@GwtIncompatible // maximumWeight public void testMaximumWeight_setTwice() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().maximumWeight(16); try { // even to the same value is not allowed builder.maximumWeight(16); fail(); } catch (IllegalStateException expected) { } try { builder.maximumSize(16); fail(); } catch (IllegalStateException expected) { } }
@GwtIncompatible // maximumWeight public void testMaximumWeight_negative() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder(); try { builder.maximumWeight(-1); fail(); } catch (IllegalArgumentException expected) { } }
@Inject public NetflowV9CodecAggregator() { // TODO customize this.templateCache = CacheBuilder.newBuilder() .maximumSize(5000) .removalListener(notification -> LOG.debug("Removed {} from template cache for reason {}", notification.getKey(), notification.getCause())) .recordStats() .build(); this.packetCache = CacheBuilder.newBuilder() .expireAfterWrite(1, TimeUnit.MINUTES) .maximumWeight(Size.megabytes(1).toBytes()) .removalListener((RemovalListener<TemplateKey, Queue<PacketBytes>>) notification -> LOG.debug("Removed {} from packet cache for reason {}", notification.getKey(), notification.getCause())) .weigher((key, value) -> value.stream().map(PacketBytes::readableBytes).reduce(0, Integer::sum)) .recordStats() .build(); }
builder.weigher(weigher); if (maxWeight != UNSET_INT) { builder.maximumWeight(maxWeight);
builder.maximumWeight(maximumWeight);
@GwtIncompatible // maximumWeight public void testMaximumWeight_withoutWeigher() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().maximumWeight(1); try { builder.build(identityLoader()); fail(); } catch (IllegalStateException expected) { } }
public void testEviction_setMaxSegmentWeight() { IdentityLoader<Object> loader = identityLoader(); for (int i = 1; i < 1000; i++) { LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().maximumWeight(i).weigher(constantWeigher(1)).build(loader); assertEquals(i, CacheTesting.getTotalSegmentSize(cache)); } }
public void testSetWeigher() { Weigher<Object, Object> testWeigher = new Weigher<Object, Object>() { @Override public int weigh(Object key, Object value) { return 42; } }; LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().maximumWeight(1).weigher(testWeigher)); assertSame(testWeigher, map.weigher); }
public void testEviction_overweight() { // test weighted lru within a single segment IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(45) .weigher(intKeyWeigher()) .build(loader); CacheTesting.warmUp(cache, 0, 10); Set<Integer> keySet = cache.asMap().keySet(); assertThat(keySet).containsExactly(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); // add an at-the-maximum-weight entry getAll(cache, asList(45)); CacheTesting.drainRecencyQueues(cache); assertThat(keySet).containsExactly(0, 45); // add an over-the-maximum-weight entry getAll(cache, asList(46)); CacheTesting.drainRecencyQueues(cache); assertThat(keySet).contains(0); }
public void testEviction_overflow() { CountingRemovalListener<Object, Object> removalListener = countingRemovalListener(); IdentityLoader<Object> loader = identityLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(1L << 31) .weigher(constantWeigher(Integer.MAX_VALUE)) .removalListener(removalListener) .build(loader); cache.getUnchecked(objectWithHash(0)); cache.getUnchecked(objectWithHash(0)); CacheTesting.processPendingNotifications(cache); assertEquals(1, removalListener.getCount()); }
public void testEviction_maxWeightOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)) .build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(cache); }
CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(0) .weigher(evensOnly) .removalListener(removalListener)
CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(4) .weigher(intValueWeigher()) .removalListener(removalListener)
public void testParse_maximumWeight() { CacheBuilderSpec spec = parse("maximumWeight=9000"); assertNull(spec.initialCapacity); assertEquals(9000, spec.maximumWeight.longValue()); assertNull(spec.concurrencyLevel); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence( CacheBuilder.newBuilder().maximumWeight(9000), CacheBuilder.from(spec)); }
CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(45) .weigher(intKeyWeigher()) .build(loader);
public void testEviction_maxWeight() { CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)) .removalListener(removalListener) .build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertTrue(cache.size() <= MAX_SIZE); } assertEquals(MAX_SIZE, CacheTesting.accessQueueSize(cache)); assertEquals(MAX_SIZE, cache.size()); CacheTesting.processPendingNotifications(cache); assertEquals(MAX_SIZE, removalListener.getCount()); CacheTesting.checkValidState(cache); }
.concurrencyLevel(concurrencyLevel) .initialCapacity(initialCapacity) .maximumWeight(maxSize) .weigher(constantWeigher(1))); assertTrue(
.softValues() .expireAfterAccess(123, NANOSECONDS) .maximumWeight(789) .weigher(weigher) .concurrencyLevel(12)