How to use

UpfrontAllocatingPageSource

in

org.terracotta.offheapstore.paging

public ResourcePageSource(ServerSideConfiguration.Pool pool) {
 this.pool = pool;
 this.delegatePageSource = new UpfrontAllocatingPageSource(new OffHeapBufferSource(), pool.getSize(), GIGABYTES.toBytes(1), MEGABYTES.toBytes(128));
}

@Override
public void free(Page page) {
 delegatePageSource.free(page);
}

@Override
public Page allocate(int size, boolean thief, boolean victim, OffHeapStorageArea owner) {
 return delegatePageSource.allocate(size, thief, victim, owner);
}

private Page allocateAsThief(final int size, boolean victim, OffHeapStorageArea owner) {
 Page free = allocateFromFree(size, victim, owner);
    victimAllocator = victimAllocators.get(i);
    sliceAllocator = sliceAllocators.get(i);
    targets = findVictimPages(i, address, size);
   for (Page p : targets) {
    victimAllocator.free(p.address(), p.size());
    free(p);
   return allocateFromFree(size, victim, owner);
  } else {
   for (Page p : targets) {
    if (results.contains(p)) {
     victimAllocator.free(p.address(), p.size());
     free(p);
    } else {
     failedReleases.add(p);
  return allocateAsThief(size, victim, owner);
 } finally {
  synchronized (this) {

/**
 * Allocates a byte buffer of at least the given size.
 * <p>
 * This {@code BufferSource} is limited to allocating regions that are a power
 * of two in size.  Supplied sizes are therefore rounded up to the next
 * largest power of two.
 *
 * @return a buffer of at least the given size
 */
@Override
public Page allocate(int size, boolean thief, boolean victim, OffHeapStorageArea owner) {
 if (thief) {
  return allocateAsThief(size, victim, owner);
 } else {
  return allocateFromFree(size, victim, owner);
 }
}

for (ByteBuffer buffer : allocateBackingBuffers(source, toAllocate, maxChunk, minChunk, fixed)) {
 sliceAllocators.add(new PowerOfTwoAllocator(buffer.capacity()));
 victimAllocators.add(new PowerOfTwoAllocator(buffer.capacity()));

private Page allocateAsThief(final int size, boolean victim, OffHeapStorageArea owner) {
 Page free = allocateFromFree(size, victim, owner);
    victimAllocator = victimAllocators.get(i);
    sliceAllocator = sliceAllocators.get(i);
    targets = findVictimPages(i, address, size);
   for (Page p : targets) {
    victimAllocator.free(p.address(), p.size());
    free(p);
   return allocateFromFree(size, victim, owner);
  } else {
   for (Page p : targets) {
    if (results.contains(p)) {
     victimAllocator.free(p.address(), p.size());
     free(p);
    } else {
     failedReleases.add(p);
  return allocateAsThief(size, victim, owner);
 } finally {
  synchronized (this) {

/**
 * Allocates a byte buffer of at least the given size.
 * <p>
 * This {@code BufferSource} is limited to allocating regions that are a power
 * of two in size.  Supplied sizes are therefore rounded up to the next
 * largest power of two.
 *
 * @return a buffer of at least the given size
 */
@Override
public Page allocate(int size, boolean thief, boolean victim, OffHeapStorageArea owner) {
 if (thief) {
  return allocateAsThief(size, victim, owner);
 } else {
  return allocateFromFree(size, victim, owner);
 }
}

for (ByteBuffer buffer : allocateBackingBuffers(source, toAllocate, maxChunk, minChunk, fixed)) {
 sliceAllocators.add(new PowerOfTwoAllocator(buffer.capacity()));
 victimAllocators.add(new PowerOfTwoAllocator(buffer.capacity()));

@Test
public void testCrossSegmentShrinking() {
 long seed = System.nanoTime();
 Random random = new Random(seed);
 try {
  OffHeapServerStore store = new OffHeapServerStore(new UpfrontAllocatingPageSource(new OffHeapBufferSource(), MEGABYTES.toBytes(1L), MEGABYTES.toBytes(1)), DEFAULT_MAPPER, false);
  ByteBuffer smallValue = ByteBuffer.allocate(1024);
  for (int i = 0; i < 10000; i++) {
   try {
    store.getAndAppend(random.nextInt(500), smallValue.duplicate());
   } catch (OversizeMappingException e) {
    //ignore
   }
  }
  ByteBuffer largeValue = ByteBuffer.allocate(100 * 1024);
  for (int i = 0; i < 10000; i++) {
   try {
    store.getAndAppend(random.nextInt(500), largeValue.duplicate());
   } catch (OversizeMappingException e) {
    //ignore
   }
  }
 } catch (Throwable t) {
  throw (AssertionError) new AssertionError("Failed with seed " + seed).initCause(t);
 }
}

private EhcacheConcurrentOffHeapClockCache<K, OffHeapValueHolder<V>> createBackingMap(long size, Serializer<K> keySerializer, Serializer<V> valueSerializer, SwitchableEvictionAdvisor<K, OffHeapValueHolder<V>> evictionAdvisor) {
 HeuristicConfiguration config = new HeuristicConfiguration(size);
 PageSource source = new UpfrontAllocatingPageSource(getBufferSource(), config.getMaximumSize(), config.getMaximumChunkSize(), config.getMinimumChunkSize());
 Portability<K> keyPortability = new SerializerPortability<>(keySerializer);
 Portability<OffHeapValueHolder<V>> elementPortability = new OffHeapValueHolderPortability<>(valueSerializer);
 Factory<OffHeapBufferStorageEngine<K, OffHeapValueHolder<V>>> storageEngineFactory = OffHeapBufferStorageEngine.createFactory(PointerSize.INT, source, config
   .getSegmentDataPageSize(), keyPortability, elementPortability, false, true);
 Factory<? extends PinnableSegment<K, OffHeapValueHolder<V>>> segmentFactory = new EhcacheSegmentFactory<>(
  source,
  storageEngineFactory,
  config.getInitialSegmentTableSize(),
  evictionAdvisor,
  mapEvictionListener);
 return new EhcacheConcurrentOffHeapClockCache<>(evictionAdvisor, segmentFactory, config.getConcurrency());
}

SerializationProvider serializationProvider = new DefaultSerializationProvider(null);
serializationProvider.start(providerContaining());
PageSource pageSource = new UpfrontAllocatingPageSource(getBufferSource(), configuration.getMaximumSize(), configuration.getMaximumChunkSize(), configuration.getMinimumChunkSize());
Serializer<String> keySerializer = serializationProvider.createKeySerializer(String.class, EhcacheConcurrentOffHeapClockCacheTest.class.getClassLoader());
Serializer<String> valueSerializer = serializationProvider.createValueSerializer(String.class, EhcacheConcurrentOffHeapClockCacheTest.class.getClassLoader());

SerializationProvider serializationProvider = new DefaultSerializationProvider(null);
serializationProvider.start(providerContaining());
PageSource pageSource = new UpfrontAllocatingPageSource(getBufferSource(), configuration.getMaximumSize(), configuration.getMaximumChunkSize(), configuration.getMinimumChunkSize());
Serializer<String> keySerializer = serializationProvider.createKeySerializer(String.class, EhcacheSegmentTest.class.getClassLoader());
Serializer<String> valueSerializer = serializationProvider.createValueSerializer(String.class, EhcacheSegmentTest.class.getClassLoader());

@Test
public void testContinualAppendCausingEvictionIsStable() {
 UpfrontAllocatingPageSource pageSource = new UpfrontAllocatingPageSource(new OffHeapBufferSource(), KILOBYTES.toBytes(1024L), KILOBYTES.toBytes(1024));
 if (steal) {
  OffHeapChainMap<String> mapA = new OffHeapChainMap<>(pageSource, StringPortability.INSTANCE, minPageSize, maxPageSize, true);

@Test
public void testServerSideUsageStats() {
 long maxBytes = MEGABYTES.toBytes(1);
 OffHeapServerStore store = new OffHeapServerStore(new UpfrontAllocatingPageSource(new OffHeapBufferSource(), maxBytes, MEGABYTES.toBytes(1)), new KeySegmentMapper(16), false);
 int oneKb = 1024;
 long smallLoopCount = 5;
 ByteBuffer smallValue = ByteBuffer.allocate(oneKb);
 for (long i = 0; i < smallLoopCount; i++) {
  store.getAndAppend(i, smallValue.duplicate());
 }
 Assert.assertThat(store.getAllocatedMemory(),lessThanOrEqualTo(maxBytes));
 Assert.assertThat(store.getAllocatedMemory(),greaterThanOrEqualTo(smallLoopCount * oneKb));
 Assert.assertThat(store.getAllocatedMemory(),greaterThanOrEqualTo(store.getOccupiedMemory()));
 //asserts above already guarantee that occupiedMemory <= maxBytes and that occupiedMemory <= allocatedMemory
 Assert.assertThat(store.getOccupiedMemory(),greaterThanOrEqualTo(smallLoopCount * oneKb));
 Assert.assertThat(store.getSize(), is(smallLoopCount));
 int multiplier = 100;
 long largeLoopCount = 5 + smallLoopCount;
 ByteBuffer largeValue = ByteBuffer.allocate(multiplier * oneKb);
 for (long i = smallLoopCount; i < largeLoopCount; i++) {
  store.getAndAppend(i, largeValue.duplicate());
 }
 Assert.assertThat(store.getAllocatedMemory(),lessThanOrEqualTo(maxBytes));
 Assert.assertThat(store.getAllocatedMemory(),greaterThanOrEqualTo( (smallLoopCount * oneKb) + ( (largeLoopCount - smallLoopCount) * oneKb * multiplier) ));
 Assert.assertThat(store.getAllocatedMemory(),greaterThanOrEqualTo(store.getOccupiedMemory()));
 //asserts above already guarantee that occupiedMemory <= maxBytes and that occupiedMemory <= allocatedMemory
 Assert.assertThat(store.getOccupiedMemory(),greaterThanOrEqualTo(smallLoopCount * oneKb));
 Assert.assertThat(store.getSize(), is(smallLoopCount + (largeLoopCount - smallLoopCount)));
}

private EhcacheConcurrentOffHeapClockCache<K, OffHeapValueHolder<V>> createBackingMap(long size, Serializer<K> keySerializer, Serializer<V> valueSerializer, SwitchableEvictionAdvisor<K, OffHeapValueHolder<V>> evictionAdvisor) {
 HeuristicConfiguration config = new HeuristicConfiguration(size);
 PageSource source = new UpfrontAllocatingPageSource(getBufferSource(), config.getMaximumSize(), config.getMaximumChunkSize(), config.getMinimumChunkSize());
 Portability<K> keyPortability = new SerializerPortability<>(keySerializer);
 Portability<OffHeapValueHolder<V>> elementPortability = new OffHeapValueHolderPortability<>(valueSerializer);
 Factory<OffHeapBufferStorageEngine<K, OffHeapValueHolder<V>>> storageEngineFactory = OffHeapBufferStorageEngine.createFactory(PointerSize.INT, source, config
   .getSegmentDataPageSize(), keyPortability, elementPortability, false, true);
 Factory<? extends PinnableSegment<K, OffHeapValueHolder<V>>> segmentFactory = new EhcacheSegmentFactory<>(
  source,
  storageEngineFactory,
  config.getInitialSegmentTableSize(),
  evictionAdvisor,
  mapEvictionListener);
 return new EhcacheConcurrentOffHeapClockCache<>(evictionAdvisor, segmentFactory, config.getConcurrency());
}