Package org.terracotta.offheapstore.concurrent

Class AbstractConcurrentOffHeapMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

org.terracotta.offheapstore.concurrent.AbstractConcurrentOffHeapMap<K,V>

Type Parameters:

K - the type of keys maintained by this map

V - the type of mapped values

All Implemented Interfaces:

java.util.concurrent.ConcurrentMap<K,V>, java.util.Map<K,V>, ConcurrentMapInternals, HashingMap<K,V>, MapInternals

Direct Known Subclasses:

AbstractConcurrentOffHeapCache, AbstractPersistentConcurrentOffHeapMap, ConcurrentOffHeapHashMap, ConcurrentWriteLockedOffHeapHashMap

public abstract class AbstractConcurrentOffHeapMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentMap<K,V>, ConcurrentMapInternals, HashingMap<K,V>

An abstract concurrent (striped) off-heap map.

This is an n-way hashcode striped map implementation. Subclasses must provide a Factory instance at construction time from which the required number of segments are created.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) class	AbstractConcurrentOffHeapMap.AggregatedValuesCollection
(package private) class	AbstractConcurrentOffHeapMap.AggregateEntrySet
protected class	AbstractConcurrentOffHeapMap.AggregateIterator<T>
(package private) class	AbstractConcurrentOffHeapMap.AggregateKeySet
private class	AbstractConcurrentOffHeapMap.BaseAggregateSet<T>

Nested classes/interfaces inherited from class java.util.AbstractMap

java.util.AbstractMap.SimpleEntry<K extends java.lang.Object,V extends java.lang.Object>, java.util.AbstractMap.SimpleImmutableEntry<K extends java.lang.Object,V extends java.lang.Object>

Nested classes/interfaces inherited from interface java.util.Map

java.util.Map.Entry<K extends java.lang.Object,V extends java.lang.Object>

Field Summary

Fields

Modifier and Type	Field	Description
private static int	DEFAULT_CONCURRENCY
private java.util.Set<java.util.Map.Entry<K,V>>	entrySet
private java.util.Set<K>	keySet
private static int	MAX_SEGMENTS
private int	segmentMask
protected Segment<K,V>[]	segments
private int	segmentShift
private java.util.Collection<V>	values

Constructor Summary

Constructors

Constructor	Description
AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory)	Create a concurrent map using a default number of segments.
AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory, int concurrency)	Create a concurrent map with a defined number of segments.

Method Summary

Modifier and Type	Method	Description
void	clear()
MetadataTuple<V>	computeIfAbsentWithMetadata(K key, java.util.function.Function<? super K,? extends MetadataTuple<V>> mappingFunction)
MetadataTuple<V>	computeIfPresentWithMetadata(K key, java.util.function.BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)
MetadataTuple<V>	computeWithMetadata(K key, java.util.function.BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)
boolean	containsKey(java.lang.Object key)
boolean	containsValue(java.lang.Object value)
void	destroy()
java.util.Set<java.util.Map.Entry<K,V>>	entrySet()
V	fill(K key, V value)	See OffHeapHashMap.fill(Object, Object) for a detailed description.
V	fill(K key, V value, int metadata)
V	get(java.lang.Object key)
long	getAllocatedMemory()
java.lang.Integer	getAndSetMetadata(K key, int mask, int values)
protected int	getConcurrency()
long	getDataAllocatedMemory()
long	getDataOccupiedMemory()
long	getDataSize()
long	getDataVitalMemory()
int	getIndexFor(int hash)
java.lang.Integer	getMetadata(K key, int mask)
long	getOccupiedMemory()
long	getRemovedSlotCount()
int	getReprobeLength()
java.util.List<MapInternals>	getSegmentInternals()
java.util.List<Segment<K,V>>	getSegments()
long	getSize()
long	getTableCapacity()
long	getUsedSlotCount()
V	getValueAndSetMetadata(K key, int mask, int values)
long	getVitalMemory()
boolean	handleOversizeMappingException(int hash)
java.util.Set<K>	keySet()
V	put(K key, V value)
V	put(K key, V value, int metadata)
V	putIfAbsent(K key, V value)
protected void	readLockAll()
protected void	readUnlockAll()
V	remove(java.lang.Object key)
boolean	remove(java.lang.Object key, java.lang.Object value)
java.util.Map<K,V>	removeAllWithHash(int keyHash)	Remove all keys having a specific hashcode.
boolean	removeNoReturn(java.lang.Object key)
V	replace(K key, V value)
boolean	replace(K key, V oldValue, V newValue)
protected Segment<K,V>	segmentFor(int hash)
protected Segment<K,V>	segmentFor(java.lang.Object key)
int	size()
private static int	spread(int hash)
java.util.Collection<V>	values()
void	writeLockAll()
void	writeUnlockAll()

Methods inherited from class java.util.AbstractMap

clone, equals, hashCode, isEmpty, putAll, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map

equals, hashCode, isEmpty, putAll

Field Detail

MAX_SEGMENTS

private static final int MAX_SEGMENTS

See Also:

Constant Field Values

DEFAULT_CONCURRENCY

private static final int DEFAULT_CONCURRENCY

See Also:

Constant Field Values

segments

protected final Segment<K,V>[] segments

segmentShift

private final int segmentShift

segmentMask

private final int segmentMask

keySet

private java.util.Set<K> keySet

entrySet

private java.util.Set<java.util.Map.Entry<K,V>> entrySet

values

private java.util.Collection<V> values

Constructor Detail

AbstractConcurrentOffHeapMap

public AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory)

Create a concurrent map using a default number of segments.

Parameters:

segmentFactory - factory used to create the map segments

AbstractConcurrentOffHeapMap

public AbstractConcurrentOffHeapMap(Factory<? extends Segment<K,V>> segmentFactory,
                                    int concurrency)

Create a concurrent map with a defined number of segments.

Parameters:

segmentFactory - factory used to create the map segments

concurrency - number of segments in the map

Throws:

java.lang.IllegalArgumentException - if the supplied number of segments is negative

Method Detail

segmentFor

protected Segment<K,V> segmentFor(java.lang.Object key)

segmentFor

protected Segment<K,V> segmentFor(int hash)

getIndexFor

public int getIndexFor(int hash)

getSegments

public java.util.List<Segment<K,V>> getSegments()

getConcurrency

protected int getConcurrency()

spread

private static int spread(int hash)

size

public int size()

Specified by:

size in interface java.util.Map<K,V>

Overrides:

size in class java.util.AbstractMap<K,V>

containsKey

public boolean containsKey(java.lang.Object key)

Specified by:

containsKey in interface java.util.Map<K,V>

Overrides:

containsKey in class java.util.AbstractMap<K,V>

containsValue

public boolean containsValue(java.lang.Object value)

Specified by:

containsValue in interface java.util.Map<K,V>

Overrides:

containsValue in class java.util.AbstractMap<K,V>

get

public V get(java.lang.Object key)

Specified by:

get in interface java.util.Map<K,V>

Overrides:

get in class java.util.AbstractMap<K,V>

put

public V put(K key,
             V value)

Specified by:

put in interface java.util.Map<K,V>

Overrides:

put in class java.util.AbstractMap<K,V>

put

public V put(K key,
             V value,
             int metadata)

fill

public V fill(K key,
              V value)

See OffHeapHashMap.fill(Object, Object) for a detailed description.

Parameters:

key - key with which the specified value is to be associated

value - value to be associated with the specified key

Returns:

the previous value associated with key, or null if there was no mapping for key (irrespective of whether the value was successfully installed).

fill

public V fill(K key,
              V value,
              int metadata)

remove

public V remove(java.lang.Object key)

Specified by:

remove in interface java.util.Map<K,V>

Overrides:

remove in class java.util.AbstractMap<K,V>

removeNoReturn

public boolean removeNoReturn(java.lang.Object key)

getMetadata

public java.lang.Integer getMetadata(K key,
                                     int mask)
                              throws java.lang.IllegalArgumentException

Throws:

java.lang.IllegalArgumentException

getAndSetMetadata

public java.lang.Integer getAndSetMetadata(K key,
                                           int mask,
                                           int values)
                                    throws java.lang.IllegalArgumentException

Throws:

java.lang.IllegalArgumentException

getValueAndSetMetadata

public V getValueAndSetMetadata(K key,
                                int mask,
                                int values)

clear

public void clear()

Specified by:

clear in interface java.util.Map<K,V>

Overrides:

clear in class java.util.AbstractMap<K,V>

destroy

public void destroy()

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Specified by:

putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface java.util.Map<K,V>

remove

public boolean remove(java.lang.Object key,
                      java.lang.Object value)

Specified by:

remove in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

remove in interface java.util.Map<K,V>

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

replace in interface java.util.Map<K,V>

replace

public V replace(K key,
                 V value)

Specified by:

replace in interface java.util.concurrent.ConcurrentMap<K,V>

Specified by:

replace in interface java.util.Map<K,V>

keySet

public java.util.Set<K> keySet()

Specified by:

keySet in interface java.util.Map<K,V>

Overrides:

keySet in class java.util.AbstractMap<K,V>

values

public java.util.Collection<V> values()

Specified by:

values in interface java.util.Map<K,V>

Overrides:

values in class java.util.AbstractMap<K,V>

entrySet

public java.util.Set<java.util.Map.Entry<K,V>> entrySet()

Specified by:

entrySet in interface java.util.Map<K,V>

Specified by:

entrySet in class java.util.AbstractMap<K,V>

readLockAll

protected void readLockAll()

readUnlockAll

protected void readUnlockAll()

writeLockAll

public final void writeLockAll()

writeUnlockAll

public final void writeUnlockAll()

getSegmentInternals

public java.util.List<MapInternals> getSegmentInternals()

Specified by:

getSegmentInternals in interface ConcurrentMapInternals

getSize

public long getSize()

Specified by:

getSize in interface MapInternals

getTableCapacity

public long getTableCapacity()

Specified by:

getTableCapacity in interface MapInternals

getUsedSlotCount

public long getUsedSlotCount()

Specified by:

getUsedSlotCount in interface MapInternals

getRemovedSlotCount

public long getRemovedSlotCount()

Specified by:

getRemovedSlotCount in interface MapInternals

getReprobeLength

public int getReprobeLength()

Specified by:

getReprobeLength in interface MapInternals

getAllocatedMemory

public long getAllocatedMemory()

Specified by:

getAllocatedMemory in interface MapInternals

getOccupiedMemory

public long getOccupiedMemory()

Specified by:

getOccupiedMemory in interface MapInternals

getVitalMemory

public long getVitalMemory()

Specified by:

getVitalMemory in interface MapInternals

getDataAllocatedMemory

public long getDataAllocatedMemory()

Specified by:

getDataAllocatedMemory in interface MapInternals

getDataOccupiedMemory

public long getDataOccupiedMemory()

Specified by:

getDataOccupiedMemory in interface MapInternals

getDataVitalMemory

public long getDataVitalMemory()

Specified by:

getDataVitalMemory in interface MapInternals

getDataSize

public long getDataSize()

Specified by:

getDataSize in interface MapInternals

handleOversizeMappingException

public final boolean handleOversizeMappingException(int hash)

computeWithMetadata

public MetadataTuple<V> computeWithMetadata(K key,
                                            java.util.function.BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)

computeIfAbsentWithMetadata

public MetadataTuple<V> computeIfAbsentWithMetadata(K key,
                                                    java.util.function.Function<? super K,? extends MetadataTuple<V>> mappingFunction)

computeIfPresentWithMetadata

public MetadataTuple<V> computeIfPresentWithMetadata(K key,
                                                     java.util.function.BiFunction<? super K,? super MetadataTuple<V>,? extends MetadataTuple<V>> remappingFunction)

removeAllWithHash

public java.util.Map<K,V> removeAllWithHash(int keyHash)

Description copied from interface: HashingMap

Remove all keys having a specific hashcode.

Specified by:

removeAllWithHash in interface HashingMap<K,V>

Parameters:

keyHash - the hashcode of the keys to be removed.

Returns:

a Map containing the removed mappings.