public void evict() throws InterruptedException { while (!shouldEvict()) { evictLock.lock(); try { if (!shouldEvict()) { nothingToEvict.await(); long evictionFragmentMaxSize = (long) (this.getMaxSize() * bufferProperties.getEvictionFragmentSizePercentage()); long fragmentSize = 0; int elementsInFragment = 0; substractFromCurrentSize(fragmentSize);
/** * {@inheritDoc} * <p> * This method is thread safe. */ public boolean shouldEvict() { return getOccupancyPercentage() > Float.intBitsToFloat(evictionOccupancyPercentage.get()); }
/** * {@inheritDoc} */ @Override public boolean process(IBufferElement<E> elementToProcess, IBufferElement<E> lastProcessedElement) { // only thread that execute compare and set successfully can perform changes if (lastProcessed.compareAndSet(lastProcessedElement, elementToProcess)) { // perform analysis elementToProcess.calculateAndSetBufferElementSize(atomicBuffer.objectSizes); elementToProcess.setBufferElementState(BufferElementState.ANALYZED); atomicBuffer.addToCurrentSize(elementToProcess.getBufferElementSize(), true); atomicBuffer.elementsAnalyzed.incrementAndGet(); return true; } return false; }
when(bufferProperties.getIndexingWaitTime()).thenReturn(10L); when(indexingTree.getComponentSize(objectSizes)).thenReturn(10L); buffer.postConstruct(); buffer.put(bufferElement); while ((buffer.getAnalyzedElements() < elements) || (buffer.getIndexedElements() < elements)) { Thread.sleep(50); assertThat(buffer.getCurrentSize(), is(elements + 10L)); verify(indexingTree, atLeast(1)).getComponentSize(objectSizes); } else { assertThat(buffer.getCurrentSize(), is(elements)); verify(indexingTree, times(0)).getComponentSize(objectSizes); assertThat(buffer.shouldEvict(), is(true)); buffer.evict(); long evicted = buffer.getEvictedElemenets(); buffer.put(new BufferElement<>(defaultData)); buffer.put(new BufferElement<>(defaultData)); while ((buffer.getAnalyzedElements() < (elements + 2)) || (buffer.getIndexedElements() < (elements + 2))) { Thread.sleep(50);
buffer.postConstruct(); first = bufferElement; buffer.put(bufferElement); while (buffer.getAnalyzedElements() < firstRunElements) { Thread.sleep(50); assertThat(buffer.getCurrentSize(), is(firstRunElements)); assertThat(buffer.getOccupancyPercentage(), is((float) firstRunElements / elements)); assertThat(buffer.shouldEvict(), is(false)); buffer.put(bufferElement); while (buffer.getAnalyzedElements() < elements) { Thread.sleep(50); assertThat(buffer.getCurrentSize(), is(elements)); assertThat(buffer.getOccupancyPercentage(), is(1f)); assertThat(buffer.shouldEvict(), is(true)); assertThat(buffer.getAnalyzedElements(), is(elements)); for (int i = 0; i < elements; i++) { assertThat(first.isAnalyzed(), is(true));
when(bufferProperties.getEvictionOccupancyPercentage()).thenReturn(0.1f); when(bufferProperties.getEvictionFragmentSizePercentage()).thenReturn(0.5f); buffer.postConstruct(); buffer.put(bufferElement); while (buffer.getAnalyzedElements() < elements) { Thread.sleep(50); buffer.evict(); assertThat(buffer.getCurrentSize(), is(elements / 2)); assertThat(buffer.getInsertedElemenets(), is(elements)); assertThat(buffer.getEvictedElemenets(), is(elements / 2));
buffer.put(bufferElement); buffer.put(bufferElement); buffer.clearAll(); buffer.put(bufferElement); while ((buffer.getAnalyzedElements() < elements) || (buffer.getIndexedElements() < elements)) { Thread.sleep(500); bufferIndexer.interrupt(); assertThat(buffer.getCurrentSize(), is(elements)); assertThat(buffer.getAnalyzedElements(), is(elements)); assertThat(buffer.getIndexedElements(), is(elements)); assertThat(buffer.getEvictedElemenets(), is(0L));
long elementSize = 10; when(objectSizes.getObjectSecurityExpansionRate()).thenReturn(expansionRate); buffer.postConstruct(); buffer.put(bufferElement); while (buffer.getAnalyzedElements() < elements) { Thread.sleep(50); assertThat(buffer.getCurrentSize(), is((long) (elements * elementSize * (1 + expansionRate))));
first = bufferElement; buffer.put(bufferElement); while ((buffer.getAnalyzedElements() < elements) || (buffer.getIndexedElements() < elements)) { Thread.sleep(50); assertThat(buffer.getIndexedElements(), is(elements)); verify(indexingTree, times((int) elements)).put(defaultData);
/** * Checks if the eviction should start, and if it does notifies the right thread. */ private void notifyEvictionIfNeeded() { if (shouldEvict()) { evictLock.lock(); try { nothingToEvict.signal(); } finally { evictLock.unlock(); } } }
/** * Init. * * @throws Exception */ @BeforeMethod public void init() throws Exception { MockitoAnnotations.initMocks(this); buffer = new AtomicBuffer<>(); buffer.bufferProperties = bufferProperties; buffer.objectSizes = objectSizes; buffer.indexingTree = indexingTree; buffer.log = LoggerFactory.getLogger(AtomicBuffer.class); when(bufferProperties.getIndexingTreeCleaningThreads()).thenReturn(1); buffer.postConstruct(); }
@Test public void increaseBufferSizeWithOccupancy() throws Exception { Configuration configuration = propertyManager.getConfiguration(); SingleProperty<Float> maxOldSpaceOcc = configuration.forLogicalName("buffer.maxOldSpaceOccupancy"); SingleProperty<Float> minOldSpaceOcc = configuration.forLogicalName("buffer.minOldSpaceOccupancy"); long oldBufferSize = bufferProperties.getInitialBufferSize(); ConfigurationUpdate configurationUpdate = new ConfigurationUpdate(); configurationUpdate.addPropertyUpdate(maxOldSpaceOcc.createAndValidatePropertyUpdate(Float.valueOf(maxOldSpaceOcc.getValue().floatValue() + 0.05f))); configurationUpdate.addPropertyUpdate(minOldSpaceOcc.createAndValidatePropertyUpdate(Float.valueOf(minOldSpaceOcc.getValue().floatValue() + 0.05f))); propertyManager.updateConfiguration(configurationUpdate, false); long newBufferSize = bufferProperties.getInitialBufferSize(); assertThat(newBufferSize, is(greaterThan(oldBufferSize))); assertThat(newBufferSize, is(buffer.getMaxSize())); }
/** * {@inheritDoc} */ @Override public String toString() { StringBuffer msg = new StringBuffer(256); msg.append("The buffer occupancy status: "); msg.append(NumberFormat.getInstance().format(currentSize.get())); msg.append(" bytes occupied from total "); msg.append(NumberFormat.getInstance().format(maxSize.get())); msg.append(" bytes available ("); msg.append(NumberFormat.getInstance().format(getOccupancyPercentage() * 100)); msg.append("%).\nElements processed in the buffer since last clear buffer:\n-Elements added: "); msg.append(NumberFormat.getInstance().format(elementsAdded.get())); msg.append("\n-Elements analyzed: "); msg.append(NumberFormat.getInstance().format(elementsAnalyzed.get())); msg.append("\n-Elements indexed: "); msg.append(NumberFormat.getInstance().format(elementsIndexed.get())); msg.append("\n-Elements evicted: "); msg.append(NumberFormat.getInstance().format(elementsEvicted.get())); msg.append('\n'); return msg.toString(); }
long oldSize = atomicBuffer.indexingTreeSize.get(); if (atomicBuffer.indexingTreeSize.compareAndSet(oldSize, newSize)) { atomicBuffer.addToCurrentSize(newSize - oldSize, false); if (atomicBuffer.log.isDebugEnabled()) { atomicBuffer.log.debug("Indexing tree size update duration: " + Converter.nanoToMilliseconds(System.nanoTime() - time));