package org.apache.directmemory;
/*
* 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 static com.google.common.base.Preconditions.checkArgument;
import static java.lang.String.format;
import static org.apache.directmemory.measures.In.seconds;
import static org.apache.directmemory.serialization.SerializerFactory.createNewSerializer;
import java.util.concurrent.ConcurrentMap;
import org.apache.directmemory.cache.CacheService;
import org.apache.directmemory.cache.CacheServiceImpl;
import org.apache.directmemory.measures.Ram;
import org.apache.directmemory.memory.MemoryManagerService;
import org.apache.directmemory.memory.MemoryManagerServiceImpl;
import org.apache.directmemory.memory.Pointer;
import org.apache.directmemory.serialization.Serializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.MapMaker;
public final class DirectMemory<K, V>
{
public static final int DEFAULT_CONCURRENCY_LEVEL = 4;
public static final int DEFAULT_INITIAL_CAPACITY = 100000;
public static final int DEFAULT_DISPOSAL_TIME = 10; // seconds
private final Logger logger = LoggerFactory.getLogger( getClass() );
private int numberOfBuffers;
private int size;
private int initialCapacity = DEFAULT_INITIAL_CAPACITY;
private int concurrencyLevel = DEFAULT_CONCURRENCY_LEVEL;
private long disposalTime = seconds( DEFAULT_DISPOSAL_TIME );
private ConcurrentMap<K, Pointer<V>> map;
private Serializer serializer;
private MemoryManagerService<V> memoryManager;
public DirectMemory()
{
// does nothing
}
public DirectMemory( DirectMemory<K, V> prototype )
{
checkArgument( prototype != null, "Impossible to create a DirectMemory instance from a null prototype" );
numberOfBuffers = prototype.numberOfBuffers;
size = prototype.size;
initialCapacity = prototype.initialCapacity;
concurrencyLevel = prototype.concurrencyLevel;
disposalTime = prototype.disposalTime;
map = prototype.map;
serializer = prototype.serializer;
memoryManager = prototype.memoryManager;
}
public DirectMemory<K, V> setNumberOfBuffers( int numberOfBuffers )
{
checkArgument( numberOfBuffers > 0, "Impossible to create a CacheService with a number of buffers lesser than 1" );
this.numberOfBuffers = numberOfBuffers;
return this;
}
public DirectMemory<K, V> setSize( int size )
{
checkArgument( size > 0, "Impossible to create a CacheService with a size lesser than 1" );
this.size = size;
return this;
}
public DirectMemory<K, V> setInitialCapacity( int initialCapacity )
{
checkArgument( initialCapacity > 0, "Impossible to create a CacheService with an initialCapacity lesser than 1" );
this.initialCapacity = initialCapacity;
return this;
}
public DirectMemory<K, V> setConcurrencyLevel( int concurrencyLevel )
{
checkArgument( concurrencyLevel > 0, "Impossible to create a CacheService with a concurrencyLevel lesser than 1" );
this.concurrencyLevel = concurrencyLevel;
return this;
}
public DirectMemory<K, V> setDisposalTime( long disposalTime )
{
checkArgument( disposalTime > 0, "Impossible to create a CacheService with a disposalTime lesser than 1" );
this.disposalTime = disposalTime;
return this;
}
public DirectMemory<K, V> setMap( ConcurrentMap<K, Pointer<V>> map )
{
checkArgument( map != null, "Impossible to create a CacheService with a null map" );
this.map = map;
return this;
}
public DirectMemory<K, V> setSerializer( Serializer serializer )
{
checkArgument( serializer != null, "Impossible to create a CacheService with a null serializer" );
this.serializer = serializer;
return this;
}
public DirectMemory<K, V> setMemoryManager( MemoryManagerService<V> memoryManager )
{
checkArgument( memoryManager != null, "Impossible to create a CacheService with a null memoryManager" );
this.memoryManager = memoryManager;
return this;
}
public CacheService<K, V> newCacheService()
{
if ( map == null )
{
map = new MapMaker().concurrencyLevel( concurrencyLevel ).initialCapacity( initialCapacity ).makeMap();
}
if ( memoryManager == null )
{
memoryManager = new MemoryManagerServiceImpl<V>();
}
if ( serializer == null )
{
serializer = createNewSerializer();
}
logger.info( "******************************** initializing *******************************" );
logger.info( " ____ _ __ __ ___" );
logger.info( " / __ \\(_)________ _____/ /_/ |/ /___ ____ ___ ____ _______ __" );
logger.info( " / / / / // ___/ _ \\/ ___/ __/ /|_/ // _ \\/ __ `__ \\/ __ \\/ ___/ / / /" );
logger.info( " / /_/ / // / / __/ /__/ /_/ / / // __/ / / / / / /_/ / / / /_/ / " );
logger.info( " /_____/_//_/ \\___/\\___/\\__/_/ /_/ \\___/_/ /_/ /_/\\____/_/ \\__, /" );
logger.info( " /____/ " );
logger.info( "********************************************************************************" );
memoryManager.init( numberOfBuffers, size );
logger.info( "initialized" );
logger.info( format( "number of buffer(s): \t%1d with %2s each", numberOfBuffers, Ram.inMb( size ) ) );
logger.info( format( "initial capacity: \t%1d", initialCapacity ) );
logger.info( format( "concurrency level: \t%1d", concurrencyLevel ) );
CacheService<K, V> cacheService = new CacheServiceImpl<K, V>( map, memoryManager, serializer );
cacheService.scheduleDisposalEvery( disposalTime );
return cacheService;
}
}