/*
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.util;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.romix.scala.collection.concurrent.TrieMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* A simple layer on top of maps, which performs snapshot mediation and optimization of
* what the underlying implementation is.
*/
public final class MapAdaptor {
public static final int DEFAULT_COPY_MAX_ITEMS = 100;
public static final String COPY_MAX_ITEMS_MAX_PROP = "org.opendaylight.yangtools.util.mapadaptor.maxcopy";
public static final int DEFAULT_PERSIST_MIN_ITEMS = 50;
public static final String PERSIST_MIN_ITEMS_PROP = "org.opendaylight.yangtools.util.mapadaptor.minpersist";
private static final Logger LOG = LoggerFactory.getLogger(MapAdaptor.class);
private static final MapAdaptor DEFAULT_INSTANCE;
private final boolean useSingleton;
private final int persistMinItems;
private final int copyMaxItems;
static {
DEFAULT_INSTANCE = new MapAdaptor(true,
getProperty(COPY_MAX_ITEMS_MAX_PROP, DEFAULT_COPY_MAX_ITEMS),
getProperty(PERSIST_MIN_ITEMS_PROP, DEFAULT_PERSIST_MIN_ITEMS));
LOG.debug("Configured HashMap/TrieMap cutoff at {}/{} entries",
DEFAULT_INSTANCE.persistMinItems, DEFAULT_INSTANCE.copyMaxItems);
}
private static int getProperty(final String name, final int defaultValue) {
try {
final String p = System.getProperty(name);
if (p != null) {
try {
int pi = Integer.valueOf(p);
if (pi <= 0) {
LOG.warn("Ignoring illegal value of {}: has to be a positive number", name);
} else {
return pi;
}
} catch (NumberFormatException e) {
LOG.warn("Ignoring non-numerical value of {}", name, e);
}
}
} catch (Exception e) {
LOG.debug("Failed to get {}", name, e);
}
return defaultValue;
}
private MapAdaptor(final boolean useSingleton, final int copyMaxItems, final int persistMinItems) {
this.useSingleton = useSingleton;
this.copyMaxItems = copyMaxItems;
this.persistMinItems = persistMinItems;
}
/**
* Return the default-configured instance.
*
* @return the singleton global instance
*/
public static MapAdaptor getDefaultInstance() {
return DEFAULT_INSTANCE;
}
public static MapAdaptor getInstance(final boolean useSingleton, final int copyMaxItems,
final int persistMinItems) {
Preconditions.checkArgument(copyMaxItems >= 0, "copyMaxItems has to be a non-negative integer");
Preconditions.checkArgument(persistMinItems >= 0, "persistMinItems has to be a positive integer");
Preconditions.checkArgument(persistMinItems <= copyMaxItems,
"persistMinItems must be less than or equal to copyMaxItems");
return new MapAdaptor(useSingleton, copyMaxItems, persistMinItems);
}
/**
* Creates an initial snapshot. The backing map is selected according to
* the expected size.
*
* @param expectedSize Expected map size
* @return An empty mutable map.
*/
public <K, V> Map<K, V> initialSnapshot(final int expectedSize) {
Preconditions.checkArgument(expectedSize >= 0);
if (expectedSize > persistMinItems) {
return new ReadWriteTrieMap<>();
}
if (expectedSize < 2) {
return new HashMap<>(1);
}
if (expectedSize == 2) {
return new HashMap<>(2);
}
return Maps.newHashMapWithExpectedSize(expectedSize);
}
/**
* Input is treated is supposed to be left unmodified, result must be mutable.
*/
@SuppressWarnings("static-method")
public <K, V> Map<K, V> takeSnapshot(final Map<K, V> input) {
if (input instanceof ReadOnlyTrieMap) {
return ((ReadOnlyTrieMap<K, V>)input).toReadWrite();
}
LOG.trace("Converting input {} to a HashMap", input);
/*
* The default HashMap copy constructor performs a bad thing for small maps, using the default capacity of 16
* as the minimum sizing hint, which can lead to wasted memory. Since the HashMap grows in powers-of-two, we
* only kick this in if we are storing 6 entries or less, as that results in 8-entry map -- the next power is
* 16, which is the default.
*/
final Map<K, V> ret;
final int size = input.size();
if (size <= 6) {
final int target;
switch (size) {
case 0:
case 1:
target = 1;
break;
case 2:
target = 2;
break;
case 3:
target = 4;
break;
default:
target = 8;
}
ret = new HashMap<>(target);
ret.putAll(input);
} else if (input instanceof HashMap) {
// HashMap supports cloning, but we want to make sure we trim it down if entries were removed, so we do
// this only after having checked for small sizes.
@SuppressWarnings("unchecked")
final Map<K, V> tmp = (Map<K, V>) ((HashMap<K, V>) input).clone();
ret = tmp;
} else {
ret = new HashMap<>(input);
}
LOG.trace("Read-write HashMap is {}", ret);
return ret;
}
/**
* Input will be thrown away, result will be retained for read-only access or
* {@link #takeSnapshot(Map)} purposes.
*
* @param input non-optimized (read-write) map
* @return optimized read-only map
*/
public <K, V> Map<K, V> optimize(final Map<K, V> input) {
if (input instanceof ReadOnlyTrieMap) {
LOG.warn("Optimizing read-only map {}", input);
}
final int size = input.size();
/*
* No-brainer :)
*/
if (size == 0) {
LOG.trace("Reducing input {} to an empty map", input);
return ImmutableMap.of();
}
/*
* We retain the persistent map as long as it holds at least
* persistMinItems
*/
if (input instanceof ReadWriteTrieMap && size >= persistMinItems) {
return ((ReadWriteTrieMap<K, V>)input).toReadOnly();
}
/*
* If the user opted to use singleton maps, use them. Except for the case
* when persistMinItems dictates we should not move off of the persistent
* map.
*/
if (useSingleton && size == 1) {
final Entry<K, V> e = input.entrySet().iterator().next();
final Map<K, V> ret = Collections.singletonMap(e.getKey(), e.getValue());
LOG.trace("Reducing input {} to singleton map {}", input, ret);
return ret;
}
if (size <= copyMaxItems) {
/*
* Favor access speed: use a HashMap and copy it on modification.
*/
if (input instanceof HashMap) {
return input;
}
LOG.trace("Copying input {} to a HashMap ({} entries)", input, size);
final Map<K, V> ret = new HashMap<>(input);
LOG.trace("Read-only HashMap is {}", ret);
return ret;
}
/*
* Favor isolation speed: use a TrieMap and perform snapshots
*
* This one is a bit tricky, as the TrieMap is concurrent and does not
* keep an uptodate size. Updating it requires a full walk -- which is
* O(N) and we want to avoid that. So we wrap it in an interceptor,
* which will maintain the size for us.
*/
LOG.trace("Copying input {} to a TrieMap ({} entries)", input, size);
final TrieMap<K, V> map = new TrieMap<>();
map.putAll(input);
final Map<K, V> ret = new ReadOnlyTrieMap<>(map, size);
LOG.trace("Read-only TrieMap is {}", ret);
return ret;
}
}