@Override public void clear() { if (_SHARED_CACHE != null) { _SHARED_CACHE.invalidateAll(); } }
@Override public long getSizeBytes() { return sharedCache().sizeBytes(); }
@Override public void setMaximumSize(long maxSizeBytes) throws IllegalArgumentException { final long absoluteMaximumSize = getAbsoluteMaximumSize(); checkArgument(maxSizeBytes >= 0 && maxSizeBytes <= absoluteMaximumSize, "Cache max size must be between 0 and %s, got %s", absoluteMaximumSize, maxSizeBytes); SharedCache cache = SharedCache.build(maxSizeBytes); SharedCache old = _SHARED_CACHE; _SHARED_CACHE = cache; if (old != null) { old.invalidateAll(); } this.currentMaxCacheSize = maxSizeBytes; }
public @Test void testInvalidateAll() { final int L1Capacity = 10; SharedCache cache = SharedCache.build(L1Capacity, 16 * 1024 * 1024); List<RevObject> objects = createObjects(500); objects.forEach((o) -> cache.put(repo1Id.create(o.getId()), o)); objects.forEach((o) -> cache.put(repo2Id.create(o.getId()), o)); objects.forEach((o) -> assertNotNull(cache.getIfPresent(repo1Id.create(o.getId())))); objects.forEach((o) -> assertNotNull(cache.getIfPresent(repo2Id.create(o.getId())))); cache.invalidateAll(); objects.forEach((o) -> assertNull(cache.getIfPresent(repo2Id.create(o.getId())))); objects.forEach((o) -> assertNull(cache.getIfPresent(repo1Id.create(o.getId())))); }
@Ignore // too fragile depending on the jvm test heap public @Test void testInvalidateAll() { final int L1Capacity = 10; cache = createCache(L1Capacity, 32 * 1024 * 1024); List<RevObject> objects = createObjects(500); objects.forEach((o) -> cache.put(repo1Id.create(o.getId()), o)); objects.forEach((o) -> cache.put(repo2Id.create(o.getId()), o)); objects.forEach((o) -> assertNotNull(cache.getIfPresent(repo1Id.create(o.getId())))); objects.forEach((o) -> assertNotNull(cache.getIfPresent(repo2Id.create(o.getId())))); cache.invalidateAll(); objects.forEach((o) -> assertNull(cache.getIfPresent(repo2Id.create(o.getId())))); objects.forEach((o) -> assertNull(cache.getIfPresent(repo1Id.create(o.getId())))); }
public @Test void testStats() { SharedCache sharedCache = mock(SharedCache.class); CacheStats stats = mock(CacheStats.class); when(stats.evictionCount()).thenReturn(1L); when(stats.missCount()).thenReturn(1L); when(stats.hitCount()).thenReturn(1L); when(stats.missRate()).thenReturn(0.5); when(stats.hitRate()).thenReturn(0.5); when(sharedCache.getStats()).thenReturn(stats); when(sharedCache.sizeBytes()).thenReturn(1000L); when(sharedCache.objectCount()).thenReturn(100L); cacheManager._SHARED_CACHE = sharedCache; assertEquals(1, cacheManager.getEvictionCount()); assertEquals(1, cacheManager.getMissCount()); assertEquals(0.5d, cacheManager.getMissRate(), 1e-9); assertEquals(1, cacheManager.getHitCount()); assertEquals(0.5d, cacheManager.getHitRate(), 1e-9); assertEquals(1000, cacheManager.getSizeBytes()); assertEquals(100, cacheManager.getSize()); assertEquals(1000 / (1024D * 1024D), cacheManager.getSizeMB(), 1e-9); } }
public @Test void testGetIfPresentEnsureL2Cache() throws Exception { Key k1 = repo1Id.create(obj.getId()); assertNull(cache.getIfPresent(k1)); Future<?> l2Future = cache.put(k1, obj); assertNotNull(l2Future); l2Future.get(); RevObject cached = cache.getIfPresent(k1); assertNotNull(cached); assertNull(cache.getIfPresent(repo2Id.create(obj.getId()))); assertEquals(obj, cached); }
public @Test void testL1WriteBack() { final int L1Capacity = 1000; SharedCache cache = SharedCache.build(L1Capacity, maxCacheSizeBytes); List<RevObject> objects = createObjects(100); objects.forEach((o) -> cache.put(repo1Id.create(o.getId()), o)); objects.forEach((o) -> assertNull(cache.getIfPresent(repo2Id.create(o.getId())))); objects.forEach((o) -> assertNotNull(cache.getIfPresent(repo1Id.create(o.getId())))); }
@Override public long getMissCount() { return sharedCache().getStats().missCount(); }
public TestResult run(RevObjectSerializer encoder, List<? extends RevObject> objects) { sharedCache.setEncoder(encoder); final Stopwatch put = put(objects); Collections.shuffle(objects); final Stopwatch get = Stopwatch.createStarted(); int hits = query(objects); get.stop(); long sizeBytes = sharedCache.sizeBytes(); String displayName = encoder.getDisplayName(); int size = objects.size(); long insertTimeMillis = put.elapsed(TimeUnit.MILLISECONDS); long queryTimeMillis = get.elapsed(TimeUnit.MILLISECONDS); TestResult result = new TestResult(displayName, size, hits, insertTimeMillis, queryTimeMillis, sizeBytes); return result; }
public void put(RevObject obj) { SharedCache cache = sharedCache.get(); CacheKey key = keyPrefix.create(obj.getId()); cache.put(key, obj); }
/** * Returns the cached object with the given id, if present, or {@code null} otherwise */ public @Nullable RevObject getIfPresent(ObjectId id) { return sharedCache.get().getIfPresent(keyPrefix.create(id)); } }
/** * Checks whether a given {@link ObjectId} is already cached on this {@code ObjectCache} */ public boolean contains(ObjectId id) { return sharedCache.get().contains(keyPrefix.create(id)); }
/** * Prunes the given object id from the cache */ public void invalidate(ObjectId id) { sharedCache.get().invalidate(keyPrefix.create(id)); }
/** * Creates and returns a shared cache with the given maximum heap memory capacity in bytes. * <p> * This factory method does not check whether the provided maximum capacity exceeds any JVM * limit, it's up to the calling code to make sure the provided capacity can be delivered by the * JVM heap. * * @throws IllegalArgumentException if {@code maxCacheSizeBytes} is lower than zero, with zero * meaning no caching at all. */ public static SharedCache build(final long maxCacheSizeBytes) { return SharedCache.build(Impl.L1_CACHE_SIZE, maxCacheSizeBytes); }
@Override public long getSize() { return sharedCache().objectCount(); }
public void setEncoder(@NonNull RevObjectSerializer encoder) { sharedCache().setEncoder(encoder); }