@Test(dataProvider = "empty") public void size_whenEmpty(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.size(), is(0)); }
@Test(dataProvider = "populated") public void size_whenPopulated(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.size(), is(POPULATED_SIZE)); }
@Test(dataProvider = "full") public void offer_whenFull(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.offer(1), is(false)); assertThat(buffer.size(), is(FULL_SIZE)); }
@Test(dataProvider = "populated") public void offer_whenPopulated(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.offer(1), is(true)); assertThat(buffer.size(), is(POPULATED_SIZE + 1)); }
@Test(dataProvider = "full") public void poll_toEmpty(MpscGrowableArrayQueue<Integer> buffer) { while (buffer.poll() != null) {} assertThat(buffer.size(), is(0)); }
@Test(dataProvider = "empty") public void offer_whenEmpty(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.offer(1), is(true)); assertThat(buffer.size(), is(1)); }
@Test(dataProvider = "populated") public void poll_whenPopulated(MpscGrowableArrayQueue<Integer> buffer) { assertThat(buffer.poll(), is(not(nullValue()))); assertThat(buffer.size(), is(POPULATED_SIZE - 1)); }
@Test(dataProvider = "empty") public void manyProducers_noConsumer(MpscGrowableArrayQueue<Integer> buffer) { AtomicInteger count = new AtomicInteger(); ConcurrentTestHarness.timeTasks(NUM_PRODUCERS, () -> { for (int i = 0; i < PRODUCE; i++) { if (buffer.offer(i)) { count.incrementAndGet(); } } }); assertThat(buffer.size(), is(count.get())); }
@Test(dataProvider = "caches") @CacheSpec(compute = Compute.SYNC, implementation = Implementation.Caffeine, population = Population.EMPTY, maximumSize = Maximum.FULL) public void exceedsMaximumBufferSize_onWrite(Cache<Integer, Integer> cache, CacheContext context) { BoundedLocalCache<Integer, Integer> localCache = asBoundedLocalCache(cache); boolean[] ran = new boolean[1]; localCache.afterWrite(() -> ran[0] = true); assertThat(ran[0], is(true)); assertThat(localCache.writeBuffer().size(), is(0)); }
private void drain(BoundedLocalCache<K, V> cache) { do { cache.cleanUp(); } while (cache.buffersWrites() && cache.writeBuffer().size() > 0); }
private void status() { int drainStatus; int pendingWrites; local.evictionLock.lock(); try { pendingWrites = local.writeBuffer().size(); drainStatus = local.drainStatus(); } finally { local.evictionLock.unlock(); } LocalTime elapsedTime = LocalTime.ofSecondOfDay(stopwatch.elapsed(TimeUnit.SECONDS)); System.out.printf("---------- %s ----------%n", elapsedTime); System.out.printf("Pending reads: %,d; writes: %,d%n", local.readBuffer.size(), pendingWrites); System.out.printf("Drain status = %s (%s)%n", STATUS[drainStatus], drainStatus); System.out.printf("Evictions = %,d%n", cache.stats().evictionCount()); System.out.printf("Size = %,d (max: %,d)%n", local.data.mappingCount(), operation.maxEntries); System.out.printf("Lock = [%s%n", StringUtils.substringAfter( local.evictionLock.toString(), "[")); System.out.printf("Pending tasks = %,d%n", ForkJoinPool.commonPool().getQueuedSubmissionCount()); long maxMemory = Runtime.getRuntime().maxMemory(); long freeMemory = Runtime.getRuntime().freeMemory(); long allocatedMemory = Runtime.getRuntime().totalMemory(); System.out.printf("Max Memory = %,d bytes%n", maxMemory); System.out.printf("Free Memory = %,d bytes%n", freeMemory); System.out.printf("Allocated Memory = %,d bytes%n", allocatedMemory); System.out.println(); }
@Test(dataProvider = "caches") @CacheSpec(compute = Compute.SYNC, implementation = Implementation.Caffeine, population = Population.EMPTY, maximumSize = Maximum.FULL) public void drain_onWrite(Cache<Integer, Integer> cache, CacheContext context) { BoundedLocalCache<Integer, Integer> localCache = asBoundedLocalCache(cache); cache.put(1, 1); int size = localCache.accessOrderEdenDeque().size() + localCache.accessOrderProbationDeque().size(); assertThat(localCache.writeBuffer().size(), is(0)); assertThat(size, is(1)); }
@Test(dataProvider = "empty") public void oneProducer_oneConsumer(MpscGrowableArrayQueue<Integer> buffer) { AtomicInteger started = new AtomicInteger(); AtomicInteger finished = new AtomicInteger(); ConcurrentTestHarness.execute(() -> { started.incrementAndGet(); Awaits.await().untilAtomic(started, is(2)); for (int i = 0; i < PRODUCE; i++) { while (!buffer.offer(i)) {} } finished.incrementAndGet(); }); ConcurrentTestHarness.execute(() -> { started.incrementAndGet(); Awaits.await().untilAtomic(started, is(2)); for (int i = 0; i < PRODUCE; i++) { while (buffer.poll() == null) {} } finished.incrementAndGet(); }); Awaits.await().untilAtomic(finished, is(2)); assertThat(buffer.size(), is(0)); }
@Test(dataProvider = "empty") public void manyProducers_oneConsumer(MpscGrowableArrayQueue<Integer> buffer) { AtomicInteger started = new AtomicInteger(); AtomicInteger finished = new AtomicInteger(); ConcurrentTestHarness.execute(() -> { started.incrementAndGet(); Awaits.await().untilAtomic(started, is(NUM_PRODUCERS + 1)); for (int i = 0; i < (NUM_PRODUCERS * PRODUCE); i++) { while (buffer.poll() == null) {} } finished.incrementAndGet(); }); ConcurrentTestHarness.timeTasks(NUM_PRODUCERS, () -> { started.incrementAndGet(); Awaits.await().untilAtomic(started, is(NUM_PRODUCERS + 1)); for (int i = 0; i < PRODUCE; i++) { while (!buffer.offer(i)) {} } finished.incrementAndGet(); }); Awaits.await().untilAtomic(finished, is(NUM_PRODUCERS + 1)); assertThat(buffer.size(), is(0)); }
private void checkLinks(BoundedLocalCache<K, V> cache, ImmutableList<LinkedDeque<Node<K, V>>> deques, DescriptionBuilder desc) { int size = 0; long weightedSize = 0; Set<Node<K, V>> seen = Sets.newIdentityHashSet(); for (LinkedDeque<Node<K, V>> deque : deques) { size += deque.size(); weightedSize += scanLinks(cache, seen, deque, desc); } if (cache.size() != size) { desc.expectThat(() -> "deque size " + deques, size, is(cache.size())); } Supplier<String> errorMsg = () -> String.format( "Size != list length; pending=%s, additional: %s", cache.writeBuffer().size(), Sets.difference(seen, ImmutableSet.copyOf(cache.data.values()))); desc.expectThat(errorMsg, cache.size(), is(seen.size())); final long weighted = weightedSize; if (cache.evicts()) { Supplier<String> error = () -> String.format( "WeightedSize != link weights [%d vs %d] {%d vs %d}", cache.adjustedWeightedSize(), weighted, seen.size(), cache.size()); desc.expectThat("non-negative weight", weightedSize, is(greaterThanOrEqualTo(0L))); desc.expectThat(error, cache.adjustedWeightedSize(), is(weightedSize)); } }