package org.apache.directmemory.preliminary;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import com.carrotsearch.junitbenchmarks.AbstractBenchmark;
import com.carrotsearch.junitbenchmarks.BenchmarkOptions;
import com.google.common.collect.MapMaker;
import com.google.common.collect.Maps;
import org.apache.directmemory.measures.Ram;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.ByteBuffer;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.assertNotNull;
public class PreliminarBenchmark
extends AbstractBenchmark
{
private static Logger logger = LoggerFactory.getLogger( PreliminarBenchmark.class );
final static byte payload[] = new byte[1024];
// @Before
// @After
public void cleanup()
{
dump( "Before cleanup" );
Runtime.getRuntime().gc();
dump( "After cleanup" );
logger.info( "************************************************" );
}
private void dump( String message )
{
logger.info( message );
logger.info( "Memory - max: " + Ram.inMb( Runtime.getRuntime().maxMemory() ) );
logger.info( "Memory - allocated: " + Ram.inMb( Runtime.getRuntime().totalMemory() ) );
logger.info( "Memory - free : " + Ram.inMb( Runtime.getRuntime().freeMemory() ) );
}
@BenchmarkOptions( benchmarkRounds = 5, warmupRounds = 0 )
@Test
public void justMap()
{
final Map<String, byte[]> test = Maps.newHashMap();
long ops = 100000;
for ( int i = 0; i < ops; i++ )
{
final String key = "test-" + i;
test.put( key, payload.clone() );
}
logger.info( "stored " + Ram.inMb( payload.length * ops ) );
}
@BenchmarkOptions( benchmarkRounds = 1, warmupRounds = 0 )
@Test
public void oneMillionSmallWithDirectBuffersOneAllocation()
{
logger.info( "payload is " + payload.length + " bytes" );
final byte payload[] = new byte[500];
int ops = 1000000;
pumpWithOneAllocation( ops, payload );
}
@BenchmarkOptions( benchmarkRounds = 1, warmupRounds = 0 )
@Test
public void lessButLargerWithDirectBuffersOneAllocation()
{
logger.info( "payload is " + payload.length + " bytes" );
final byte payload[] = new byte[2048];
int ops = 210000;
pumpWithOneAllocation( ops, payload );
}
/*
*
*
* ExecutorService executor = Executors.newCachedThreadPool();
Callable<Object> task = new Callable<Object>() {
public Object call() {
return something.blockingMethod();
}
}
Future<Object> future = executor.submit(task);
try {
Object result = future.get(5, TimeUnit.SECONDS);
} catch (TimeoutException ex) {
// handle the timeout
} finally {
future.cancel(); // may or may not desire this
}
*/
@BenchmarkOptions( benchmarkRounds = 5, warmupRounds = 0 )
@Test
public void withDirectBuffers150k()
{
logger.info( "payload is " + payload.length + " bytes" );
int ops = 150000;
pump( ops );
}
@BenchmarkOptions( benchmarkRounds = 5, warmupRounds = 0 )
@Test
public void withDirectBuffers180k()
{
logger.info( "payload is " + payload.length + " bytes" );
int ops = 180000;
pump( ops );
}
@BenchmarkOptions( benchmarkRounds = 5, warmupRounds = 0 )
@Test
public void withDirectBuffers150kAgain()
{
logger.info( "payload is " + payload.length + " bytes" );
int ops = 150000;
pump( ops );
}
@BenchmarkOptions( benchmarkRounds = 1, warmupRounds = 0 )
@Test
public void testAllocation()
{
logger.info( "payload is " + payload.length + " bytes" );
logger.info( "allocating " + Ram.inMb( payload.length * 200000 ) );
ByteBuffer buf = ByteBuffer.allocateDirect( payload.length * 200000 );
assertNotNull( buf );
logger.info( "done" );
}
private void pumpWithOneAllocation( int ops, byte[] payload )
{
ConcurrentMap<String, ByteBuffer> test =
new MapMaker().concurrencyLevel( 4 ).maximumSize( ops ).expireAfterWrite( 10, TimeUnit.MINUTES ).makeMap();
logger.info( Ram.inMb( ops * payload.length ) + " in " + ops + " slices to store" );
ByteBuffer bulk = ByteBuffer.allocateDirect( ops * payload.length );
double started = System.currentTimeMillis();
for ( int i = 0; i < ops; i++ )
{
bulk.position( i * payload.length );
final ByteBuffer buf = bulk.duplicate();
buf.put( payload );
test.put( "test-" + i, buf );
}
double finished = System.currentTimeMillis();
logger.info( "done in " + ( finished - started ) / 1000 + " seconds" );
for ( ByteBuffer buf : test.values() )
{
buf.clear();
}
}
@BenchmarkOptions( benchmarkRounds = 5, warmupRounds = 0 )
@Test
public void withDirectBuffers100k()
{
logger.info( "payload is " + payload.length + " bytes" );
int ops = 100000;
pump( ops );
}
private void pump( int ops )
{
ConcurrentMap<String, ByteBuffer> test =
new MapMaker().concurrencyLevel( 4 ).maximumSize( ops ).expireAfterWrite( 10, TimeUnit.MINUTES ).makeMap();
logger.info( Ram.inMb( ops * payload.length ) + " to store" );
double started = System.currentTimeMillis();
for ( int i = 0; i < ops; i++ )
{
ByteBuffer buf = ByteBuffer.allocateDirect( payload.length );
buf.put( payload );
test.put( "test-" + i, buf );
}
double finished = System.currentTimeMillis();
logger.info( "done in " + ( finished - started ) / 1000 + " seconds" );
for ( ByteBuffer buf : test.values() )
{
buf.clear();
}
}
}