Alawn/Chronicle-Map
1
0
Fork 0
mirror of https://github.com/OpenHFT/Chronicle-Map.git synced 2021-09-13 01:26:12 +00:00
Code Releases Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
Peter Lawrey
2014-11-15 10:40:42 +00:00
parent 524834f1c2 e98be88e60
commit 37914654bc
38 changed files with 1237 additions and 315 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/net/openhft/chronicle/hash/ChronicleHashBuilder.java
+5 -5
View File
@@ -45,7 +45,7 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
/**
* This interface defines the meaning of configurations, common to {@link ChronicleMapBuilder} and
* This interface defines the meaning of configurations, common to {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder} and
* {@link ChronicleSetBuilder}, i. e. <i>Chronicle hash container</i> configurations.
*
* <p>{@code ChronicleHashBuilder} is mutable. Configuration methods mutate the builder and return
@@ -56,7 +56,7 @@ import java.util.concurrent.TimeUnit;
* @param <K> the type of keys in hash containers, created by this builder
* @param <C> the container type, created by this builder, i. e. {@link ChronicleMap} or {@link
* ChronicleSet}
* @param <B> the concrete builder type, i. e. {@link ChronicleMapBuilder} or {@link
* @param <B> the concrete builder type, i. e. {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder} or {@link
* ChronicleSetBuilder}
*/
public interface ChronicleHashBuilder<K, C extends ChronicleHash,
@@ -130,7 +130,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
*
* <p>There are three major patterns of this configuration usage: <ol> <li>Key (and value, in
* {@code ChronicleMap} case) sizes are constant. Configure them via {@link
* #constantKeySizeBySample(Object)} and {@link ChronicleMapBuilder#constantValueSizeBySample(Object)}
* #constantKeySizeBySample(Object)} and {@link net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder#constantValueSizeBySample(Object)}
* methods, and you will experience no memory waste at all.</li> <li>Key (and/or value size, in
* {@code ChronicleMap} case) varies moderately. Specify them using corresponding methods, or
* specify entry size directly by calling this method, by sizes somewhere between average and
@@ -154,7 +154,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
* efficient manner, for example as {@code long[]} arrays. Typical number of connections is
* 100-300, maximum is 3000. In this case entry size of
* 50 * (8 bytes for each id) = 400 bytes would be a good choice: <pre>{@code
* Map<Long, long[]> socialGraph = ChronicleMapBuilder
* Map<Long, long[]> socialGraph = ChronicleMapOnHeapUpdatableBuilder
* .of(Long.class, long[].class)
* // given that graph should have of 1 billion nodes, and 150 average adjacency list size
* // => values takes 3 chuncks on average
@@ -183,7 +183,7 @@ public interface ChronicleHashBuilder<K, C extends ChronicleHash,
* memory unit).</li> <li>If key (and/or value, in {@code ChronicleMap} case) size varies
* moderately, you should pass to this method the maximum number of entries + 5-25%, depending
* on your data properties and configured {@linkplain #keySize(int) key}/{@linkplain
* ChronicleMapBuilder#valueSize(int) value}/{@linkplain #entrySize(int) entry} sizes.</li>
* net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder#valueSize(int) value}/{@linkplain #entrySize(int) entry} sizes.</li>
* <li>If your data size varies in a wide range, pass the maximum number of entries multiplied
* by average data size and divided by the configured "entry size" (i. e. chunk size). See an
* example in the documentation to {@link #entrySize(int)} method.</li> </ol>
src/main/java/net/openhft/chronicle/java8/Function.java
+27
View File
@@ -0,0 +1,27 @@
package net.openhft.chronicle.java8;
import java.io.Serializable;
/**
* Represents a function that accepts one argument and produces a result.
*
* <p>This is a <a href="package-summary.html">functional interface</a> whose functional method is {@link
* #apply(Object)}.
*
* @param <T> the type of the input to the function
* @param <R> the type of the result of the function
* @since 1.8
*/
public interface Function<T, R> extends Serializable {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}
src/main/java/net/openhft/chronicle/map/AbstractChronicleMapBuilder.java
+9 -11
View File
@@ -57,19 +57,19 @@ import static net.openhft.chronicle.map.Objects.builderEquals;
/**
* {@code AbstractChronicleMapBuilder} manages most of {@link ChronicleMap} configurations; has two concrete
* subclasses: {@link ChronicleMapBuilder} should be used to create maps with ordinary values, {@link
* OffHeapUpdatableChronicleMapBuilder} -- maps with {@link Byteable} values, which point directly to off-heap
* subclasses: {@link OnHeapUpdatableChronicleMapBuilder} should be used to create maps with ordinary values, {@link
* ChronicleMapBuilder} -- maps with {@link Byteable} values, which point directly to off-heap
* memory; could be used as a classic builder and/or factory. This means
* that in addition to the standard builder usage pattern: <pre>{@code
* ChronicleMap<Key, Value> map = ChronicleMapBuilder
* ChronicleMap<Key, Value> map = ChronicleMapOnHeapUpdatableBuilder
* .of(Key.class, Value.class)
* .entries(100500)
* // ... other configurations
* .create();}</pre>
* one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link ChronicleMapBuilder} or {@link
* OffHeapUpdatableChronicleMapBuilder}, could be prepared and used to create many similar
* one of concrete {@code AbstractChronicleMapBuilder} subclasses, {@link OnHeapUpdatableChronicleMapBuilder} or {@link
* ChronicleMapBuilder}, could be prepared and used to create many similar
* maps: <pre>{@code
* OffHeapUpdatableChronicleMapBuilder<Key, Value> builder = OffHeapUpdatableChronicleMapBuilder
* ChronicleMapBuilder<Key, Value> builder = ChronicleMapBuilder
* .of(Key.class, Value.class)
* .entries(100500);
*
@@ -201,7 +201,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
*
* <p>Example: if keys in your map(s) are English words in {@link String} form, keys size 10
* (a bit more than average English word length) would be a good choice: <pre>{@code
* ChronicleMap<String, LongValue> wordFrequencies = OffHeapUpdatableChronicleMapBuilder
* ChronicleMap<String, LongValue> wordFrequencies = ChronicleMapBuilder
* .of(String.class, LongValue.class)
* .entries(50000)
* .keySize(10)
@@ -532,7 +532,7 @@ public abstract class AbstractChronicleMapBuilder<K, V,
@Override
public String toString() {
return "ChronicleMapBuilder{" +
return "ChronicleMapOnHeapUpdatableBuilder{" +
"actualSegments=" + pretty(actualSegments) +
", minSegments=" + pretty(minSegments) +
", actualEntriesPerSegment=" + pretty(actualEntriesPerSegment) +
@@ -839,12 +839,10 @@ public abstract class AbstractChronicleMapBuilder<K, V,
}
/**
* Only for testing. Shouldn't be called concurrently on a single builder instance.
*
* @param identifier id
* @return map
*/
ChronicleMap<K, V> createReplicated(byte identifier) throws IOException {
public ChronicleMap<K, V> createReplicated(byte identifier) throws IOException {
preMapConstruction(true);
VanillaChronicleMap<K, ?, ?, V, ?, ?> map =
new ReplicatedChronicleMap<K, Object, MetaBytesInterop<K, Object>,
src/main/java/net/openhft/chronicle/map/Alignment.java
+1 -1
View File
@@ -23,7 +23,7 @@ import net.openhft.lang.io.Bytes;
/**
* Memory addresses alignment strategies.
*
* @see OffHeapUpdatableChronicleMapBuilder#entryAndValueAlignment(Alignment)
* @see ChronicleMapBuilder#entryAndValueAlignment(Alignment)
*/
public enum Alignment {
/**
src/main/java/net/openhft/chronicle/map/ChronicleMap.java
+4 -4
View File
@@ -93,7 +93,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
* for the key
* @see #get(Object)
* @see #acquireUsing(Object, Object)
* @see ChronicleMapBuilder#valueMarshaller(BytesMarshaller)
* @see OnHeapUpdatableChronicleMapBuilder#valueMarshaller(BytesMarshaller)
*/
V getUsing(K key, V usingValue);
@@ -134,7 +134,7 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
* no mapping for the key
* @see #get(Object)
* @see #getUsing(Object, Object)
* @see ChronicleMapBuilder#valueMarshaller(BytesMarshaller)
* @see OnHeapUpdatableChronicleMapBuilder#valueMarshaller(BytesMarshaller)
*/
@NotNull
ReadContext<K, V> getUsingLocked(@NotNull K key, @NotNull V usingValue);
@@ -166,8 +166,8 @@ public interface ChronicleMap<K, V> extends ConcurrentMap<K, V>, ChronicleHash {
* defaultValueProvider.}
*
* <p>If the {@code ChronicleMap} is off-heap updatable, i. e. created via {@link
* OffHeapUpdatableChronicleMapBuilder} builder (values are {@link Byteable}), there is one more option of
* what to do if the key is absent in the map, see {@link OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}.
* ChronicleMapBuilder} builder (values are {@link Byteable}), there is one more option of
* what to do if the key is absent in the map, see {@link ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)}.
* By default, value bytes are just zeroed out, no default value, either provided for key or constant, is
* put for the absent key.
*
src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java
+360 -164
View File
@@ -1,154 +1,216 @@
/*
* Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
*
* Licensed 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.
*/
package net.openhft.chronicle.map;
import net.openhft.chronicle.hash.ChronicleHashBuilder;
import net.openhft.chronicle.hash.serialization.*;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshallable;
import net.openhft.chronicle.hash.ChronicleHashErrorListener;
import net.openhft.chronicle.hash.ChronicleHashInstanceConfig;
import net.openhft.chronicle.hash.StatelessClientConfig;
import net.openhft.chronicle.hash.replication.SingleChronicleHashReplication;
import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
import net.openhft.chronicle.hash.replication.TimeProvider;
import net.openhft.chronicle.hash.serialization.BytesReader;
import net.openhft.chronicle.hash.serialization.BytesWriter;
import net.openhft.chronicle.hash.serialization.SizeMarshaller;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.serialization.BytesMarshallerFactory;
import net.openhft.lang.io.serialization.ObjectFactory;
import net.openhft.lang.io.serialization.ObjectSerializer;
import net.openhft.lang.model.Byteable;
import net.openhft.lang.model.DataValueClasses;
import org.jetbrains.annotations.NotNull;
import java.io.Externalizable;
import java.io.Serializable;
import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;
/**
* {@code ChronicleMapBuilder} is intended to be used to configure {@link ChronicleMap}s with
* non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives
* ({@link Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values
* implementing {@link BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface,
* or any other values for which {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller}
* is provided.
*
* <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain
* a {@code ChronicleMapBuilder} instance.
* {@code ChronicleMapBuilder} is intended to be used to create {@link ChronicleMap}s
*
* @param <K> key type of the maps, created by this builder
* @param <V> value type of the maps, created by this builder
* @see OffHeapUpdatableChronicleMapBuilder
* @see AbstractChronicleMapBuilder
* @see ChronicleHashBuilder
* @see net.openhft.chronicle.hash.ChronicleHashBuilder
*/
public final class ChronicleMapBuilder<K, V>
extends AbstractChronicleMapBuilder<K, V, ChronicleMapBuilder<K, V>> {
public final class ChronicleMapBuilder<K, V> implements ChronicleMapBuilderI<K, V> {
final ChronicleMapBuilderI<K, V> delegate;
/**
* Returns a new {@code ChronicleMapBuilder} instance which is able to {@linkplain #create()
* create} maps with the specified key and value classes.
* Returns a new {@code ChronicleMapBuilder} instance which is able to {@linkplain #create() create} maps
* with the specified key and value classes.
*
* <p>{@code ChronicleMapBuilder} analyzes provided key and value classes and automatically
* chooses the most specific and effective serializer which it is aware about. Read
* <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
* serialization in Chronicle Map manual</a> for more information.
* <p>{@code ChronicleMapBuilder} analyzes provided key and value classes and automatically chooses the
* most specific internal builder.
*
* @param keyClass class object used to infer key type and discover it's properties
* via reflection
* @param valueClass class object used to infer value type and discover it's properties
* via reflection
* @param <K> key type of the maps, created by the returned builder
* @param <V> value type of the maps, created by the returned builder
* @param keyClass class object used to infer key type and discover it's properties via reflection
* @param valueClass class object used to infer value type and discover it's properties via reflection
* @param <K> key type of the maps, created by the returned builder
* @param <V> value type of the maps, created by the returned builder
* @return a new builder for the given key and value classes
*/
public static <K, V> ChronicleMapBuilder<K, V> of(
@NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
return new ChronicleMapBuilder<K, V>(keyClass, valueClass);
if (valueClass.isEnum())
return new ChronicleMapBuilder<K, V>(OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass));
if (keyClass.isInterface() && keyClass != CharSequence.class) {
keyClass = DataValueClasses.directClassFor(keyClass);
}
if ((valueClass.isInterface() && valueClass != CharSequence.class)) {
valueClass = DataValueClasses.directClassFor(valueClass);
} else if (!offHeapReference(valueClass)) {
return new ChronicleMapBuilder<K, V>(OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass));
}
OffHeapUpdatableChronicleMapBuilder<K, V> kvOffHeapUpdatableChronicleMapBuilder = new
OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
return new ChronicleMapBuilder<K, V>(kvOffHeapUpdatableChronicleMapBuilder);
}
ChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
super(keyClass, valueClass);
ChronicleMapBuilder(ChronicleMapBuilderI<K, V> delegate) {
this.delegate = delegate;
}
private static boolean offHeapReference(Class valueClass) {
return Byteable.class.isAssignableFrom(valueClass);
}
/**
* {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
*
* <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
* #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
* alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
* bytes).
*
* @see #entryAndValueAlignment(Alignment) // * @see #entries(long)
*/
@Override
ChronicleMapBuilder<K, V> self() {
public ChronicleMapBuilder<K, V> entrySize(int entrySize) {
delegate.entrySize(entrySize);
return this;
}
/**
* {@inheritDoc}
* Configures alignment strategy of address in memory of entries and independently of address in memory of
* values within entries in ChronicleMaps, created by this builder.
*
* @see #constantKeySizeBySample(Object)
* @see #valueSize(int)
* @see #entrySize(int)
* <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
* because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
* architectures any misaligned memory access is more expensive than aligned.
*
* <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
* if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
* aligned to 8 bytes).
*
* <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
*
* @param alignment the new alignment of the maps constructed by this builder
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
*/
@Override
public ChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
delegate.entryAndValueAlignment(alignment);
return this;
}
/**
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
* {@code ChronicleMapBuilder}.
*
* <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
* prepare value bytes routine} is specified instead.
*
* @see #defaultValueProvider(DefaultValueProvider)
* @see #prepareValueBytesOnAcquire(PrepareValueBytes)
*/
@Override
public ChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
delegate.defaultValue(defaultValue);
return this;
}
/**
* Configures the procedure which is called on the bytes, which later the returned value is pointing to,
* if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
* created by this builder. See {@link PrepareValueBytes} for more information.
*
* <p>The default preparation callback zeroes out the value bytes.
*
* @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
* net.openhft.lang.model.Byteable} value to return from {@code acquireUsing()}
* call
* @return this builder back
* @see PrepareValueBytes
* @see #defaultValue(Object)
* @see #defaultValueProvider(DefaultValueProvider)
*/
@Override
public ChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(@NotNull PrepareValueBytes<K, V> prepareValueBytes) {
delegate.prepareValueBytesOnAcquire(prepareValueBytes);
return this;
}
@Override
public ChronicleMapBuilder<K, V> keySize(int keySize) {
return super.keySize(keySize);
delegate.keySize(keySize);
return this;
}
/**
* {@inheritDoc}
*
* @see #keySize(int)
* @see #constantValueSizeBySample(Object)
*/
@Override
public ChronicleMapBuilder<K, V> constantKeySizeBySample(K sampleKey) {
return super.constantKeySizeBySample(sampleKey);
delegate.constantKeySizeBySample(sampleKey);
return this;
}
/**
* Configures the optimal number of bytes, taken by serialized form of values, put into maps,
* created by this builder. If value size is always the same, call {@link
* #constantValueSizeBySample(Object)} method instead of this one.
* Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
* this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
* instead of this one.
*
* <p>If value is a boxed primitive type, i. e. if value size is known statically,
* it is automatically accounted and shouldn't be specified by user.
* <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
* accounted and shouldn't be specified by user.
*
* <p>If value size varies moderately, specify the size higher than average, but lower than the
* maximum possible, to minimize average memory overuse. If value size varies in a wide range,
* it's better to use {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it
* directly.
* <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
* possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
* {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
*
* @param valueSize number of bytes, taken by serialized form of values
* @return this {@code ChronicleMapBuilder} back
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
* @see #constantValueSizeBySample(Object)
* @see #keySize(int)
* @see #entrySize(int)
*/
@Override
public ChronicleMapBuilder<K, V> valueSize(int valueSize) {
return super.valueSize(valueSize);
delegate.valueSize(valueSize);
return this;
}
/**
* Configures the constant number of bytes, taken by serialized form of values, put into maps,
* created by this builder. This is done by providing the {@code sampleValue}, all values should
* take the same number of bytes in serialized form, as this sample object.
* Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
* this builder. This is done by providing the {@code sampleValue}, all values should take the same number
* of bytes in serialized form, as this sample object.
*
* <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is
* known statically, it is automatically accounted and this method shouldn't be called.
* <p>If values are of boxed primitive type or {@link net.openhft.lang.model.Byteable} subclass, i. e. if
* value size is known statically, it is automatically accounted and this method shouldn't be called.
*
* <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be
* called instead of this one.
* <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
* instead of this one.
*
* @param sampleValue the sample value
* @return this builder back
* @see #valueSize(int)
* @see #constantKeySizeBySample(Object)
*/
@Override
public ChronicleMapBuilder<K, V> constantValueSizeBySample(
@NotNull V sampleValue) {
return super.constantValueSizeBySample(sampleValue);
public ChronicleMapBuilder<K, V> constantValueSizeBySample(@NotNull V sampleValue) {
delegate.constantValueSizeBySample(sampleValue);
return this;
}
/**
@@ -161,124 +223,258 @@ public final class ChronicleMapBuilder<K, V>
* // this class hasn't implemented yet, just for example
* .objectSerializer(new KryoObjectSerializer())
* .create();}</pre>
*
* <p>This serializer is used to serialize both keys and values, if they both require this:
* loosely typed, nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and
* {@linkplain #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
*/
@Override
public ChronicleMapBuilder<K, V> objectSerializer(
@NotNull ObjectSerializer objectSerializer) {
return super.objectSerializer(objectSerializer);
public ChronicleMapBuilder<K, V> objectSerializer(@NotNull ObjectSerializer objectSerializer) {
delegate.objectSerializer(objectSerializer);
return this;
}
/**
* {@inheritDoc}
*
* @throws IllegalStateException if custom value marshaller is specified or value class is not either
* {@code BytesMarshallable} or {@code Externalizable}
*/
@Override
public ChronicleMapBuilder<K, V> valueDeserializationFactory(@NotNull ObjectFactory<V> valueDeserializationFactory) {
delegate.valueDeserializationFactory(valueDeserializationFactory);
return this;
}
/**
* {@inheritDoc}
*
* <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured,
* this configuration is unused, because it is incapsulated in {@link
* BytesMarshaller#read(Bytes)} method (without provided instance to read the data into),
* i. e. it's is the user-side responsibility. Actually this is just a convenience method
* supporting value marshaller configurations, made initially during {@link #of(Class, Class)}
* call, if the value class is {@link BytesMarshallable} or {@link Externalizable} subclass.
*
* @throws IllegalStateException if custom value marshaller is specified or value class is not
* either {@code BytesMarshallable} or {@code Externalizable}
*/
@Override
public ChronicleMapBuilder<K, V> valueDeserializationFactory(
@NotNull ObjectFactory<V> valueDeserializationFactory) {
return super.valueDeserializationFactory(valueDeserializationFactory);
}
/**
* {@inheritDoc}
*
* <p>By default, the default value is set to {@code null}.
*
* @see #defaultValueProvider(DefaultValueProvider)
*/
@Override
public ChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
return super.defaultValue(defaultValue);
}
/**
* {@inheritDoc}
*
* <p>By default, default value provider is not specified, {@link #defaultValue(Object) default
* value} is specified instead.
* <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
* specified instead.
*
* @see #defaultValue(Object)
*/
@Override
public ChronicleMapBuilder<K, V> defaultValueProvider(
@NotNull DefaultValueProvider<K, V> defaultValueProvider) {
return super.defaultValueProvider(defaultValueProvider);
public ChronicleMapBuilder<K, V> defaultValueProvider(@NotNull DefaultValueProvider<K, V> defaultValueProvider) {
delegate.defaultValueProvider(defaultValueProvider);
return this;
}
/**
* Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap
* memory in maps, created by this builder. See
* <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
* maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* @param valueMarshaller the marshaller used to serialize values
* @return this builder back
* @see #valueMarshallers(BytesWriter, BytesReader)
* @see OffHeapUpdatableChronicleMapBuilder
* @see #valueMarshallers(net.openhft.chronicle.hash.serialization.BytesWriter,
* net.openhft.chronicle.hash.serialization.BytesReader)
* @see ChronicleMapBuilder
* @see #objectSerializer(ObjectSerializer)
*/
@Override
public ChronicleMapBuilder<K, V> valueMarshaller(
@NotNull BytesMarshaller<V> valueMarshaller) {
valueBuilder.marshaller(valueMarshaller);
delegate.valueMarshaller(valueMarshaller);
return this;
}
/**
* Configures the marshallers, used to serialize/deserialize values to/from off-heap
* memory in maps, created by this builder. See
* <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about
* serialization in ChronicleMap manual</a> for more information.
* Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
* created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* <p>Configuring marshalling this way results to a little bit more compact in-memory layout
* of the map, comparing to a single interface configuration:
* {@link #valueMarshaller(BytesMarshaller)}.
* <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
* comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
*
* <p>Passing {@link BytesInterop} instead of plain {@link BytesWriter} is, of cause, possible,
* but currently pointless for values.
* <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
* net.openhft.chronicle.hash.serialization.BytesWriter} is, of cause, possible, but currently pointless
* for values.
*
* @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
* @param valueReader the new {@link Bytes} &rarr; value object reader strategy
* @param valueWriter the new value object &rarr; {@link net.openhft.lang.io.Bytes} writer (interop)
* strategy
* @param valueReader the new {@link net.openhft.lang.io.Bytes} &rarr; value object reader strategy
* @return this builder back
* @see #valueMarshaller(BytesMarshaller)
*/
public ChronicleMapBuilder<K, V> valueMarshallers(
@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
valueBuilder.writer(valueWriter);
valueBuilder.reader(valueReader);
@Override
public ChronicleMapBuilder<K, V> valueMarshallers(@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
delegate.valueMarshallers(valueWriter, valueReader);
return this;
}
/**
* Configures the marshaller used to serialize actual value sizes to off-heap memory in maps,
* created by this builder.
* Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
* this builder.
*
* <p>Default value size marshaller is so-called {@linkplain SizeMarshallers#stopBit()
* stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant
* value size} is configured, or defaulted if the value type is always constant and {@code
* ChronicleHashBuilder} implementation knows about it, this configuration takes no effect,
* because a special {@link SizeMarshaller} implementation, which doesn't actually do any
* marshalling, and just returns the known constant size on {@link SizeMarshaller#readSize(
* Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this method.
* <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
* stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
* is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
* implementation knows about it, this configuration takes no effect, because a special {@link
* net.openhft.chronicle.hash.serialization.SizeMarshaller} implementation, which doesn't actually do any
* marshalling, and just returns the known constant size on {@link net.openhft.chronicle.hash.serialization.SizeMarshaller#readSize(
*net.openhft.lang.io.Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this
* method.
*
* @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to
* off-heap memory
* @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
* @return this builder back
*/
public ChronicleMapBuilder<K, V> valueSizeMarshaller(
@NotNull SizeMarshaller valueSizeMarshaller) {
valueBuilder.sizeMarshaller(valueSizeMarshaller);
@Override
public ChronicleMapBuilder<K, V> valueSizeMarshaller(@NotNull SizeMarshaller valueSizeMarshaller) {
delegate.valueSizeMarshaller(valueSizeMarshaller);
return this;
}
@Override
public ChronicleMapBuilder<K, V> entries(long l) {
delegate.entries(l);
return this;
}
@Override
public ChronicleMapBuilder<K, V> replication(SingleChronicleHashReplication withId) {
delegate.replication(withId);
return this;
}
@Override
public ChronicleMap create() throws IOException {
return delegate.create();
}
@Override
public ChronicleMapBuilder<K, V> actualSegments(int actualSegments) {
delegate.actualSegments(actualSegments);
return this;
}
@Override
public ChronicleMapBuilder<K, V> minSegments(int minSegments) {
delegate.minSegments(minSegments);
return this;
}
@Override
public ChronicleMapBuilder<K, V> actualEntriesPerSegment(long actualEntriesPerSegment) {
delegate.actualEntriesPerSegment(actualEntriesPerSegment);
return this;
}
@Override
public ChronicleMapBuilder<K, V> lockTimeOut(long lockTimeOut, TimeUnit unit) {
delegate.lockTimeOut(lockTimeOut, unit);
return this;
}
@Override
public ChronicleMapBuilder<K, V> errorListener(ChronicleHashErrorListener errorListener) {
delegate.errorListener(errorListener);
return this;
}
@Override
public ChronicleMapBuilder<K, V> metaDataBytes(int metaDataBytes) {
delegate.metaDataBytes(metaDataBytes);
return this;
}
@Override
public ChronicleMapBuilder<K, V> timeProvider(TimeProvider timeProvider) {
delegate.timeProvider(timeProvider);
return this;
}
@Override
public ChronicleMapBuilder<K, V> bytesMarshallerFactory(BytesMarshallerFactory bytesMarshallerFactory) {
delegate.bytesMarshallerFactory(bytesMarshallerFactory);
return this;
}
@Override
public ChronicleMapBuilder<K, V> keyMarshaller(BytesMarshaller<K> keyMarshaller) {
delegate.keyMarshaller(keyMarshaller);
return this;
}
@Override
public ChronicleMapBuilder<K, V> keyMarshallers(BytesWriter<K> keyWriter, BytesReader<K> keyReader) {
delegate.keyMarshallers(keyWriter, keyReader);
return this;
}
@Override
public ChronicleMapBuilder<K, V> keySizeMarshaller(SizeMarshaller keySizeMarshaller) {
delegate.keySizeMarshaller(keySizeMarshaller);
return this;
}
@Override
public ChronicleMapBuilder<K, V> keyDeserializationFactory(ObjectFactory<K> keyDeserializationFactory) {
delegate.keyDeserializationFactory(keyDeserializationFactory);
return this;
}
@Override
public ChronicleMapBuilder<K, V> immutableKeys() {
delegate.immutableKeys();
return this;
}
@Override
public StatelessClientConfig<ChronicleMap<K, V>> statelessClient(InetSocketAddress remoteAddress) {
return delegate.statelessClient(remoteAddress);
}
@Override
public ChronicleHashInstanceConfig<ChronicleMap<K, V>> instance() {
return delegate.instance();
}
@Override
public ChronicleMapBuilder<K, V> replication(byte identifier) {
delegate.replication(identifier);
return this;
}
@Override
public ChronicleMapBuilder<K, V> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork) {
delegate.replication(identifier, tcpTransportAndNetwork);
return this;
}
@Override
public ChronicleMapBuilder<K, V> clone() {
delegate.clone();
return this;
}
@Override
public ChronicleMapBuilder<K, V> putReturnsNull(boolean b) {
delegate.putReturnsNull(b);
return this;
}
@Override
public ChronicleMapBuilder<K, V> removeReturnsNull(boolean b) {
delegate.removeReturnsNull(b);
return this;
}
@Override
public ChronicleMapBuilder<K, V> eventListener(MapEventListener<K, V, ChronicleMap<K, V>> eventListener) {
delegate.eventListener(eventListener);
return this;
}
@Override
public ChronicleMap<K, V> createReplicated(byte b) throws IOException {
return delegate.createReplicated(b);
}
@Override
public ChronicleMap<K, V> createPersistedTo(File file) throws IOException {
return delegate.createPersistedTo(file);
}
}
src/main/java/net/openhft/chronicle/map/ChronicleMapBuilderI.java
+299
View File
@@ -0,0 +1,299 @@
package net.openhft.chronicle.map;
import net.openhft.chronicle.hash.ChronicleHashErrorListener;
import net.openhft.chronicle.hash.ChronicleHashInstanceConfig;
import net.openhft.chronicle.hash.StatelessClientConfig;
import net.openhft.chronicle.hash.replication.SingleChronicleHashReplication;
import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
import net.openhft.chronicle.hash.replication.TimeProvider;
import net.openhft.chronicle.hash.serialization.BytesReader;
import net.openhft.chronicle.hash.serialization.BytesWriter;
import net.openhft.chronicle.hash.serialization.SizeMarshaller;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.serialization.BytesMarshallerFactory;
import net.openhft.lang.io.serialization.ObjectFactory;
import net.openhft.lang.io.serialization.ObjectSerializer;
import org.jetbrains.annotations.NotNull;
import java.io.File;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;
/**
* @author Rob Austin.
*/
interface ChronicleMapBuilderI<K, V> {
/**
* {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
*
* <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
* #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
* alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
* bytes).
*
* @see #entryAndValueAlignment(Alignment) // * @see #entries(long)
*/
ChronicleMapBuilderI<K, V> entrySize(int entrySize);
/**
* Configures alignment strategy of address in memory of entries and independently of address in memory of
* values within entries in ChronicleMaps, created by this builder.
*
* <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
* because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
* architectures any misaligned memory access is more expensive than aligned.
*
* <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
* if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
* aligned to 8 bytes).
*
* <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
*
* @param alignment the new alignment of the maps constructed by this builder
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
*/
ChronicleMapBuilderI<K, V> entryAndValueAlignment(Alignment alignment);
/**
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
* {@code ChronicleMapBuilder}.
*
* <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
* prepare value bytes routine} is specified instead.
*
* @see #defaultValueProvider(DefaultValueProvider)
* @see #prepareValueBytesOnAcquire(PrepareValueBytes)
*/
ChronicleMapBuilderI<K, V> defaultValue(V defaultValue);
/**
* Configures the procedure which is called on the bytes, which later the returned value is pointing to,
* if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
* created by this builder. See {@link PrepareValueBytes} for more information.
*
* <p>The default preparation callback zeroes out the value bytes.
*
* @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
* net.openhft.lang.model.Byteable} value to return from {@code acquireUsing()}
* call
* @return this builder back
* @see PrepareValueBytes
* @see #defaultValue(Object)
* @see #defaultValueProvider(DefaultValueProvider)
*/
ChronicleMapBuilderI<K, V> prepareValueBytesOnAcquire(
@NotNull PrepareValueBytes<K, V> prepareValueBytes);
/**
* {@inheritDoc}
*
* @see #constantKeySizeBySample(Object)
* @see #valueSize(int)
* @see #entrySize(int)
*/
ChronicleMapBuilderI<K, V> keySize(int keySize);
/**
* {@inheritDoc}
*
* @see #keySize(int)
* @see #constantValueSizeBySample(Object)
*/
ChronicleMapBuilderI<K, V> constantKeySizeBySample(K sampleKey);
/**
* Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
* this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
* instead of this one.
*
* <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
* accounted and shouldn't be specified by user.
*
* <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
* possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
* {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
*
* @param valueSize number of bytes, taken by serialized form of values
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
* @see #constantValueSizeBySample(Object)
* @see #keySize(int)
* @see #entrySize(int)
*/
ChronicleMapBuilderI<K, V> valueSize(int valueSize);
/**
* Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
* this builder. This is done by providing the {@code sampleValue}, all values should take the same number
* of bytes in serialized form, as this sample object.
*
* <p>If values are of boxed primitive type or {@link net.openhft.lang.model.Byteable} subclass, i. e. if
* value size is known statically, it is automatically accounted and this method shouldn't be called.
*
* <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
* instead of this one.
*
* @param sampleValue the sample value
* @return this builder back
* @see #valueSize(int)
* @see #constantKeySizeBySample(Object)
*/
ChronicleMapBuilderI<K, V> constantValueSizeBySample(
@NotNull V sampleValue);
/**
* {@inheritDoc}
*
* <p>Example: <pre>{@code Map<Key, Value> map =
* ChronicleMapBuilder.of(Key.class, Value.class)
* .entries(1_000_000)
* .keySize(50).valueSize(200)
* // this class hasn't implemented yet, just for example
* .objectSerializer(new KryoObjectSerializer())
* .create();}</pre>
*/
ChronicleMapBuilderI<K, V> objectSerializer(
@NotNull ObjectSerializer objectSerializer);
/**
* {@inheritDoc}
*
* @throws IllegalStateException if custom value marshaller is specified or value class is not either
* {@code BytesMarshallable} or {@code Externalizable}
*/
ChronicleMapBuilderI<K, V> valueDeserializationFactory(
@NotNull ObjectFactory<V> valueDeserializationFactory);
/**
* {@inheritDoc}
*
* <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
* specified instead.
*
* @see #defaultValue(Object)
*/
ChronicleMapBuilderI<K, V> defaultValueProvider(
@NotNull DefaultValueProvider<K, V> defaultValueProvider);
/**
* Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
* maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* @param valueMarshaller the marshaller used to serialize values
* @return this builder back
* @see #valueMarshallers(net.openhft.chronicle.hash.serialization.BytesWriter,
* net.openhft.chronicle.hash.serialization.BytesReader)
* @see ChronicleMapBuilder
* @see #objectSerializer(ObjectSerializer)
*/
ChronicleMapBuilderI<K, V> valueMarshaller(
@NotNull BytesMarshaller<V> valueMarshaller);
/**
* Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
* created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
* comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
*
* <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
* net.openhft.chronicle.hash.serialization.BytesWriter} is, of cause, possible, but currently pointless
* for values.
*
* @param valueWriter the new value object &rarr; {@link net.openhft.lang.io.Bytes} writer (interop)
* strategy
* @param valueReader the new {@link net.openhft.lang.io.Bytes} &rarr; value object reader strategy
* @return this builder back
* @see #valueMarshaller(BytesMarshaller)
*/
ChronicleMapBuilderI<K, V> valueMarshallers(
@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader);
/**
* Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
* this builder.
*
* <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
* stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
* is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
* implementation knows about it, this configuration takes no effect, because a special {@link
* net.openhft.chronicle.hash.serialization.SizeMarshaller} implementation, which doesn't actually do any
* marshalling, and just returns the known constant size on {@link net.openhft.chronicle.hash.serialization.SizeMarshaller#readSize(
*net.openhft.lang.io.Bytes)} calls, is used instead of any {@code SizeMarshaller} configured using this
* method.
*
* @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
* @return this builder back
*/
ChronicleMapBuilderI<K, V> valueSizeMarshaller(
@NotNull SizeMarshaller valueSizeMarshaller);
ChronicleMapBuilderI<K, V> entries(long l);
ChronicleMapBuilderI<K, V> replication(SingleChronicleHashReplication withId);
ChronicleMap<K, V> create() throws IOException;
ChronicleMapBuilderI<K, V> actualSegments(int actualSegments);
ChronicleMapBuilderI<K, V> minSegments(int minSegments);
ChronicleMapBuilderI<K, V> actualEntriesPerSegment(long actualEntriesPerSegment);
ChronicleMapBuilderI<K, V> lockTimeOut(long lockTimeOut, TimeUnit unit);
ChronicleMapBuilderI<K, V> errorListener(ChronicleHashErrorListener errorListener);
ChronicleMapBuilderI<K, V> metaDataBytes(int metaDataBytes);
ChronicleMapBuilderI<K, V> timeProvider(TimeProvider timeProvider);
ChronicleMapBuilderI<K, V> bytesMarshallerFactory(BytesMarshallerFactory bytesMarshallerFactory);
ChronicleMapBuilderI<K, V> keyMarshaller(BytesMarshaller<K> keyMarshaller);
ChronicleMapBuilderI<K, V> keyMarshallers(BytesWriter<K> keyWriter, BytesReader<K> keyReader);
ChronicleMapBuilderI<K, V> keySizeMarshaller(SizeMarshaller keySizeMarshaller);
ChronicleMapBuilderI<K, V> keyDeserializationFactory(ObjectFactory<K> keyDeserializationFactory);
ChronicleMapBuilderI<K, V> immutableKeys();
ChronicleMap<K, V> createPersistedTo(File file) throws IOException;
StatelessClientConfig<ChronicleMap<K, V>> statelessClient(InetSocketAddress remoteAddress);
ChronicleHashInstanceConfig<ChronicleMap<K, V>> instance();
ChronicleMapBuilderI<K, V> replication(byte identifier);
ChronicleMapBuilderI<K, V> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork);
ChronicleMapBuilderI<K, V> clone();
ChronicleMapBuilderI<K, V> eventListener(MapEventListener<K, V, ChronicleMap<K, V>> eventListener);
ChronicleMapBuilderI<K, V> putReturnsNull(boolean b);
ChronicleMap<K, V> createReplicated(byte b) throws IOException;
ChronicleMapBuilderI<K, V> removeReturnsNull(boolean b);
}
src/main/java/net/openhft/chronicle/map/NodeDiscovery.java
-2
View File
@@ -124,8 +124,6 @@ public class NodeDiscovery {
if (proposedIdentifier == ourProposedIdentifier.get())
useAnotherIdentifier.set(true);
}
}
countDownLatch.get().countDown();
src/main/java/net/openhft/chronicle/map/OffHeapUpdatableChronicleMapBuilder.java
+63 -31
View File
@@ -16,24 +16,31 @@
package net.openhft.chronicle.map;
import net.openhft.chronicle.hash.serialization.BytesReader;
import net.openhft.chronicle.hash.serialization.BytesWriter;
import net.openhft.chronicle.hash.serialization.SizeMarshaller;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.model.Byteable;
import net.openhft.lang.model.DataValueClasses;
import org.jetbrains.annotations.NotNull;
public final class OffHeapUpdatableChronicleMapBuilder<K, V>
extends AbstractChronicleMapBuilder<K, V, OffHeapUpdatableChronicleMapBuilder<K, V>> {
final class OffHeapUpdatableChronicleMapBuilder<K, V>
extends AbstractChronicleMapBuilder<K, V, OffHeapUpdatableChronicleMapBuilder<K, V>> implements ChronicleMapBuilderI<K, V> {
public static <K, V> OffHeapUpdatableChronicleMapBuilder<K, V> of(
public static <K, V> ChronicleMapBuilderI<K, V> of(
@NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
if (valueClass.isEnum())
return OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass);
if (keyClass.isInterface() && keyClass != CharSequence.class) {
keyClass = DataValueClasses.directClassFor(keyClass);
}
if (valueClass.isInterface()) {
if ((valueClass.isInterface() && valueClass != CharSequence.class)) {
valueClass = DataValueClasses.directClassFor(valueClass);
} else if (!offHeapReference(valueClass)) {
throw new IllegalArgumentException(
"Value class should be either Byteable subclass or interface," +
"allowing direct Byteable implementation generation");
return OnHeapUpdatableChronicleMapBuilder.of(keyClass, valueClass);
}
return new OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
}
@@ -48,13 +55,18 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
return this;
}
@Override
public OffHeapUpdatableChronicleMapBuilder<K, V> valueSize(int valueSize) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc} With respect to {@linkplain #entryAndValueAlignment(Alignment) alignment}.
*
* <p>Note that the actual entrySize will be aligned to 4 (default {@linkplain
* #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30,
* and entry alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32
* (30 aligned to 4 bytes).
* #entryAndValueAlignment(Alignment) entry alignment}). I. e. if you set entry size to 30, and entry
* alignment is set to {@link Alignment#OF_4_BYTES}, the actual entry size will be 32 (30 aligned to 4
* bytes).
*
* @see #entryAndValueAlignment(Alignment)
* @see #entries(long)
@@ -65,21 +77,21 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
}
/**
* Configures alignment strategy of address in memory of entries and independently of address in
* memory of values within entries in ChronicleMaps, created by this builder.
* Configures alignment strategy of address in memory of entries and independently of address in memory of
* values within entries in ChronicleMaps, created by this builder.
*
* <p>Useful when values of the map are updated intensively, particularly fields with volatile
* access, because it doesn't work well if the value crosses cache lines. Also, on some
* (nowadays rare) architectures any misaligned memory access is more expensive than aligned.
* <p>Useful when values of the map are updated intensively, particularly fields with volatile access,
* because it doesn't work well if the value crosses cache lines. Also, on some (nowadays rare)
* architectures any misaligned memory access is more expensive than aligned.
*
* <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this
* alignment. I. e. if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual
* entry size will be 24 (20 aligned to 8 bytes).
* <p>Note that {@linkplain #entrySize(int) entry size} will be aligned according to this alignment. I. e.
* if you set {@code entrySize(20)} and {@link Alignment#OF_8_BYTES}, actual entry size will be 24 (20
* aligned to 8 bytes).
*
* <p>Default is {@link Alignment#OF_4_BYTES} for Byteable values.
*
* @param alignment the new alignment of the maps constructed by this builder
* @return this {@code ChronicleMapBuilder} back
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
*/
@Override
public OffHeapUpdatableChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment alignment) {
@@ -87,11 +99,11 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
}
/**
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
* configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
* {@code ChronicleMapBuilder}.
*
* <p>By default, the default value is not specified, default {@linkplain
* #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
* <p>By default, the default value is not specified, default {@linkplain #prepareValueBytesOnAcquire
* prepare value bytes routine} is specified instead.
*
* @see #defaultValueProvider(DefaultValueProvider)
* @see #prepareValueBytesOnAcquire(PrepareValueBytes)
@@ -102,8 +114,8 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
}
/**
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
* configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
* {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire} configuration to this
* {@code ChronicleMapBuilder}.
*
* <p>By default, the default value provider is not specified, default {@linkplain
* #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
@@ -118,15 +130,14 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
}
/**
* Configures the procedure which is called on the bytes, which later the returned value is
* pointing to, if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object)
* acquireUsing()} call on maps, created by this builder. See {@link PrepareValueBytes} for
* more information.
* Configures the procedure which is called on the bytes, which later the returned value is pointing to,
* if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
* created by this builder. See {@link PrepareValueBytes} for more information.
*
* <p>The default preparation callback zeroes out the value bytes.
*
* @param prepareValueBytes what to do with the value bytes before assigning them into the
* {@link Byteable} value to return from {@code acquireUsing()} call
* @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
* Byteable} value to return from {@code acquireUsing()} call
* @return this builder back
* @see PrepareValueBytes
* @see #defaultValue(Object)
@@ -137,4 +148,25 @@ public final class OffHeapUpdatableChronicleMapBuilder<K, V>
@NotNull PrepareValueBytes<K, V> prepareValueBytes) {
return super.prepareValueBytesOnAcquire(prepareValueBytes);
}
public ChronicleMapBuilderI<K, V> valueMarshaller(@NotNull BytesMarshaller<V> valueMarshaller) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
public ChronicleMapBuilderI<K, V> valueMarshallers(@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
public ChronicleMapBuilderI<K, V> valueSizeMarshaller(@NotNull SizeMarshaller valueSizeMarshaller) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
@Override
public OffHeapUpdatableChronicleMapBuilder<K, V> constantValueSizeBySample(V sampleValue) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
}
src/main/java/net/openhft/chronicle/map/OnHeapUpdatableChronicleMapBuilder.java
+311
View File
@@ -0,0 +1,311 @@
/*
* Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
*
* Licensed 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.
*/
package net.openhft.chronicle.map;
import net.openhft.chronicle.hash.ChronicleHashBuilder;
import net.openhft.chronicle.hash.serialization.BytesReader;
import net.openhft.chronicle.hash.serialization.BytesWriter;
import net.openhft.chronicle.hash.serialization.SizeMarshaller;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshallable;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.serialization.ObjectFactory;
import net.openhft.lang.io.serialization.ObjectSerializer;
import net.openhft.lang.model.Byteable;
import org.jetbrains.annotations.NotNull;
import java.io.Externalizable;
import java.io.IOException;
import java.io.Serializable;
/**
* {@code ChronicleMapOnHeapUpdatableBuilder} is intended to be used to configure {@link ChronicleMap}s with
* non-{@link Byteable} values, which don't point to off-heap memory directly, including primitives ({@link
* Long}, {@link Double}, etc.), {@link String}s and {@link CharSequence}s, values implementing {@link
* BytesMarshallable}, {@link Externalizable} or {@link Serializable} interface, or any other values for which
* {@linkplain #valueMarshaller(BytesMarshaller) custom marshaller} is provided.
*
* <p>Use static {@link #of(Class, Class) of(Key.class, Value.class)} method to obtain a {@code
* ChronicleMapOnHeapUpdatableBuilder} instance.
*
* @param <K> key type of the maps, created by this builder
* @param <V> value type of the maps, created by this builder
* @see ChronicleMapBuilder
* @see AbstractChronicleMapBuilder
* @see ChronicleHashBuilder
*/
final class OnHeapUpdatableChronicleMapBuilder<K, V>
extends AbstractChronicleMapBuilder<K, V, OnHeapUpdatableChronicleMapBuilder<K, V>> implements
ChronicleMapBuilderI<K, V> {
/**
* Returns a new {@code ChronicleMapOnHeapUpdatableBuilder} instance which is able to {@linkplain
* #create() create} maps with the specified key and value classes.
*
* <p>{@code ChronicleMapOnHeapUpdatableBuilder} analyzes provided key and value classes and automatically
* chooses the most specific and effective serializer which it is aware about. Read <a
* href="https://github.com/OpenHFT/Chronicle-Map#serialization">the section about serialization in
* Chronicle Map manual</a> for more information.
*
* @param keyClass class object used to infer key type and discover it's properties via reflection
* @param valueClass class object used to infer value type and discover it's properties via reflection
* @param <K> key type of the maps, created by the returned builder
* @param <V> value type of the maps, created by the returned builder
* @return a new builder for the given key and value classes
*/
public static <K, V> ChronicleMapBuilderI<K, V> of(
@NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
return new OnHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
}
OnHeapUpdatableChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
super(keyClass, valueClass);
}
@Override
OnHeapUpdatableChronicleMapBuilder<K, V> self() {
return this;
}
public ChronicleMap<K, V> create() throws IOException {
return super.create();
}
/**
* {@inheritDoc}
*
* @see #constantKeySizeBySample(Object)
* @see #valueSize(int)
* @see #entrySize(int)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> keySize(int keySize) {
return super.keySize(keySize);
}
/**
* {@inheritDoc}
*
* @see #keySize(int)
* @see #constantValueSizeBySample(Object)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> constantKeySizeBySample(K sampleKey) {
return super.constantKeySizeBySample(sampleKey);
}
/**
* Configures the optimal number of bytes, taken by serialized form of values, put into maps, created by
* this builder. If value size is always the same, call {@link #constantValueSizeBySample(Object)} method
* instead of this one.
*
* <p>If value is a boxed primitive type, i. e. if value size is known statically, it is automatically
* accounted and shouldn't be specified by user.
*
* <p>If value size varies moderately, specify the size higher than average, but lower than the maximum
* possible, to minimize average memory overuse. If value size varies in a wide range, it's better to use
* {@linkplain #entrySize(int) entry size} in "chunk" mode and configure it directly.
*
* @param valueSize number of bytes, taken by serialized form of values
* @return this {@code ChronicleMapOnHeapUpdatableBuilder} back
* @see #constantValueSizeBySample(Object)
* @see #keySize(int)
* @see #entrySize(int)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> valueSize(int valueSize) {
return super.valueSize(valueSize);
}
/**
* Configures the constant number of bytes, taken by serialized form of values, put into maps, created by
* this builder. This is done by providing the {@code sampleValue}, all values should take the same number
* of bytes in serialized form, as this sample object.
*
* <p>If values are of boxed primitive type or {@link Byteable} subclass, i. e. if value size is known
* statically, it is automatically accounted and this method shouldn't be called.
*
* <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
* instead of this one.
*
* @param sampleValue the sample value
* @return this builder back
* @see #valueSize(int)
* @see #constantKeySizeBySample(Object)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> constantValueSizeBySample(
@NotNull V sampleValue) {
return super.constantValueSizeBySample(sampleValue);
}
/**
* {@inheritDoc}
*
* <p>Example: <pre>{@code Map<Key, Value> map =
* ChronicleMapBuilder.of(Key.class, Value.class)
* .entries(1_000_000)
* .keySize(50).valueSize(200)
* // this class hasn't implemented yet, just for example
* .objectSerializer(new KryoObjectSerializer())
* .create();}</pre>
*
* <p>This serializer is used to serialize both keys and values, if they both require this: loosely typed,
* nullable, and custom {@linkplain #keyMarshaller(BytesMarshaller) key} and {@linkplain
* #valueMarshaller(BytesMarshaller) value} marshallers are not configured.
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> objectSerializer(
@NotNull ObjectSerializer objectSerializer) {
return super.objectSerializer(objectSerializer);
}
/**
* {@inheritDoc}
*
* <p>If {@linkplain #valueMarshaller(BytesMarshaller) custom value marshaller} is configured, this
* configuration is unused, because it is incapsulated in {@link BytesMarshaller#read(Bytes)} method
* (without provided instance to read the data into), i. e. it's is the user-side responsibility. Actually
* this is just a convenience method supporting value marshaller configurations, made initially during
* {@link #of(Class, Class)} call, if the value class is {@link BytesMarshallable} or {@link
* Externalizable} subclass.
*
* @throws IllegalStateException if custom value marshaller is specified or value class is not either
* {@code BytesMarshallable} or {@code Externalizable}
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> valueDeserializationFactory(
@NotNull ObjectFactory<V> valueDeserializationFactory) {
return super.valueDeserializationFactory(valueDeserializationFactory);
}
/**
* {@inheritDoc}
*
* <p>By default, the default value is set to {@code null}.
*
* @see #defaultValueProvider(DefaultValueProvider)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
return super.defaultValue(defaultValue);
}
/**
* {@inheritDoc}
*
* <p>By default, default value provider is not specified, {@link #defaultValue(Object) default value} is
* specified instead.
*
* @see #defaultValue(Object)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> defaultValueProvider(
@NotNull DefaultValueProvider<K, V> defaultValueProvider) {
return super.defaultValueProvider(defaultValueProvider);
}
/**
* Configures the {@code BytesMarshaller} used to serialize/deserialize values to/from off-heap memory in
* maps, created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* @param valueMarshaller the marshaller used to serialize values
* @return this builder back
* @see #valueMarshallers(BytesWriter, BytesReader)
* @see ChronicleMapBuilder
* @see #objectSerializer(ObjectSerializer)
*/
public OnHeapUpdatableChronicleMapBuilder<K, V> valueMarshaller(
@NotNull BytesMarshaller<V> valueMarshaller) {
valueBuilder.marshaller(valueMarshaller);
return this;
}
/**
* Configures the marshallers, used to serialize/deserialize values to/from off-heap memory in maps,
* created by this builder. See <a href="https://github.com/OpenHFT/Chronicle-Map#serialization">the
* section about serialization in ChronicleMap manual</a> for more information.
*
* <p>Configuring marshalling this way results to a little bit more compact in-memory layout of the map,
* comparing to a single interface configuration: {@link #valueMarshaller(BytesMarshaller)}.
*
* <p>Passing {@link net.openhft.chronicle.hash.serialization.BytesInterop} instead of plain {@link
* BytesWriter} is, of cause, possible, but currently pointless for values.
*
* @param valueWriter the new value object &rarr; {@link Bytes} writer (interop) strategy
* @param valueReader the new {@link Bytes} &rarr; value object reader strategy
* @return this builder back
* @see #valueMarshaller(BytesMarshaller)
*/
public OnHeapUpdatableChronicleMapBuilder<K, V> valueMarshallers(
@NotNull BytesWriter<V> valueWriter, @NotNull BytesReader<V> valueReader) {
valueBuilder.writer(valueWriter);
valueBuilder.reader(valueReader);
return this;
}
/**
* Configures the marshaller used to serialize actual value sizes to off-heap memory in maps, created by
* this builder.
*
* <p>Default value size marshaller is so-called {@linkplain net.openhft.chronicle.hash.serialization.SizeMarshallers#stopBit()
* stop bit encoding marshalling}. If {@linkplain #constantValueSizeBySample(Object) constant value size}
* is configured, or defaulted if the value type is always constant and {@code ChronicleHashBuilder}
* implementation knows about it, this configuration takes no effect, because a special {@link
* SizeMarshaller} implementation, which doesn't actually do any marshalling, and just returns the known
* constant size on {@link SizeMarshaller#readSize(Bytes)} calls, is used instead of any {@code
* SizeMarshaller} configured using this method.
*
* @param valueSizeMarshaller the new marshaller, used to serialize actual value sizes to off-heap memory
* @return this builder back
*/
public OnHeapUpdatableChronicleMapBuilder<K, V> valueSizeMarshaller(
@NotNull SizeMarshaller valueSizeMarshaller) {
valueBuilder.sizeMarshaller(valueSizeMarshaller);
return this;
}
/**
* Configures the procedure which is called on the bytes, which later the returned value is pointing to,
* if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object) acquireUsing()} call on maps,
* created by this builder. See {@link PrepareValueBytes} for more information.
*
* <p>The default preparation callback zeroes out the value bytes.
*
* @param prepareValueBytes what to do with the value bytes before assigning them into the {@link
* Byteable} value to return from {@code acquireUsing()} call
* @return this builder back
* @see PrepareValueBytes
* @see #defaultValue(Object)
* @see #defaultValueProvider(DefaultValueProvider)
*/
@Override
public OnHeapUpdatableChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
@NotNull PrepareValueBytes<K, V> prepareValueBytes) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
public OnHeapUpdatableChronicleMapBuilder<K, V> entryAndValueAlignment(Alignment a) {
throw new UnsupportedOperationException("not supported for this combination of key/value type");
}
}
src/main/java/net/openhft/chronicle/map/PrepareValueBytes.java
+5 -5
View File
@@ -26,11 +26,11 @@ import java.io.Serializable;
* value during {@link ChronicleMap#acquireUsing(Object, Object)
* chronicleMap.acquireUsing()} call, when the given key is absent in the map. Example: if you
* want {@code 1L} to be the off-heap updatable ChronicleMap's {@linkplain
* OffHeapUpdatableChronicleMapBuilder#defaultValue(Object) default value}, the most simple way
* to achieve this is to {@linkplain OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(
* ChronicleMapBuilder#defaultValue(Object) default value}, the most simple way
* to achieve this is to {@linkplain ChronicleMapBuilder#prepareValueBytesOnAcquire(
* PrepareValueBytes) configure} custom {@code PrepareValueBytes} strategy in {@link
* OffHeapUpdatableChronicleMapBuilder}: <pre>{@code
* OffHeapUpdatableChronicleMapBuilder.of(Key.class, LongValue.class)
* ChronicleMapBuilder}: <pre>{@code
* ChronicleMapBuilder.of(Key.class, LongValue.class)
* .prepareValueBytesOnAcquire((bytes, k) -> bytes.writeLong(1L))
* ...
* .create();}</pre>
@@ -41,7 +41,7 @@ import java.io.Serializable;
*
* @param <K> the key type of {@link ChronicleMap}, on which {@code acquireUsing()} is queried
* @param <V> the value type of {@link ChronicleMap}, on which {@code acquireUsing()} is queried
* @see OffHeapUpdatableChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)
* @see ChronicleMapBuilder#prepareValueBytesOnAcquire(PrepareValueBytes)
*/
public interface PrepareValueBytes<K, V> extends Serializable {
src/main/java/net/openhft/chronicle/map/StatelessChronicleMap.java
+10 -4
View File
@@ -20,6 +20,7 @@ package net.openhft.chronicle.map;
import com.sun.jdi.connect.spi.ClosedConnectionException;
import net.openhft.chronicle.hash.RemoteCallTimeoutException;
import net.openhft.chronicle.java8.Function;
import net.openhft.lang.io.ByteBufferBytes;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -35,7 +36,6 @@ import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.SocketChannel;
import java.util.*;
import java.util.function.Function;
import static java.nio.ByteBuffer.allocateDirect;
import static net.openhft.chronicle.map.AbstractChannelReplicator.SIZE_OF_SIZE;
@@ -138,7 +138,7 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
result = AbstractChannelReplicator.openSocketChannel(closeables);
result.connect(builder.remoteAddress());
result.socket().setTcpNoDelay(true);
result.socket().setReuseAddress(true);
doHandShaking(result);
break;
@@ -240,6 +240,11 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
if (closeables != null)
closeables.closeQuietly();
closeables = null;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
//
}
}
@@ -468,9 +473,9 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
private <R> void writeObject(@NotNull Function<V, R> function) {
long start = bytes.position();
for (; ; ) {
try {
bytes.writeObject(function);
return;
} catch (IllegalStateException e) {
@@ -480,6 +485,8 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
if (cause instanceof IOException && cause.getMessage().contains("Not enough available space")) {
LOG.debug("resizing buffer");
resizeBuffer(buffer.capacity() + 1024);
bytes.limit(bytes.capacity());
bytes.position(start);
} else
throw e;
@@ -557,7 +564,6 @@ class StatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Closeable {
writeKey(key, local);
final V value = e.getValue();
final Class<?> valueClass = value.getClass();
src/main/java/net/openhft/chronicle/map/TcpReplicator.java
+5 -9
View File
@@ -21,6 +21,7 @@ package net.openhft.chronicle.map;
import net.openhft.chronicle.hash.replication.RemoteNodeValidator;
import net.openhft.chronicle.hash.replication.TcpTransportAndNetworkConfig;
import net.openhft.chronicle.hash.replication.ThrottlingConfig;
import net.openhft.chronicle.java8.Function;
import net.openhft.lang.io.ByteBufferBytes;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.threadlocal.ThreadLocalCopies;
@@ -38,7 +39,6 @@ import java.nio.channels.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import static java.nio.channels.SelectionKey.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -1348,16 +1348,12 @@ class StatelessServerConnector<K, V> {
final ThreadLocalCopies local = keyValueSerializer.threadLocalCopies();
final K key = readKey(reader, local);
V value = using.getAndSet(null);
if (value == null) {
// a simple way to create a value
value = map.getUsing(key, null);
}
final V value = using.getAndSet(null);
final Function<V, ?> o = (Function<V, ?>) reader.readObject();
try (WriteContext<K, V> wc = map.acquireUsingLocked(key, value)) {
Object result = o.apply(value);
try (WriteContext<K, V> wc = map.lookupUsing(key, value, VanillaChronicleMap.LockType.WRITE_LOCK,
false)) {
Object result = o.apply(wc.value());
keyValueSerializer.writeObject(result, writer);
} catch (RuntimeException e) {
src/main/java/net/openhft/chronicle/map/VanillaChronicleMap.java
+3
View File
@@ -349,6 +349,9 @@ class VanillaChronicleMap<K, KI, MKI extends MetaBytesInterop<K, KI>,
replaceIfPresent);
}
enum LockType {READ_LOCK, WRITE_LOCK}
@Override
src/main/java/net/openhft/chronicle/set/ChronicleSetBuilder.java
+32 -32
View File
@@ -45,20 +45,20 @@ import java.util.concurrent.TimeUnit;
* {@code ChronicleSetBuilder} manages the whole set of {@link ChronicleSet} configurations, could be used as
* a classic builder and/or factory.
*
* <p>{@code ChronicleMapBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
* <p>{@code ChronicleMapOnHeapUpdatableBuilder} is mutable, see a note in {@link ChronicleHashBuilder} interface
* documentation.
*
* @param <E> element type of the sets, created by this builder
* @see ChronicleSet
* @see ChronicleMapBuilder
* @see net.openhft.chronicle.map.ChronicleMapOnHeapUpdatableBuilder
*/
public class ChronicleSetBuilder<E>
implements ChronicleHashBuilder<E, ChronicleSet<E>, ChronicleSetBuilder<E>> {
private ChronicleMapBuilder<E, DummyValue> chronicleMapBuilder;
private ChronicleMapBuilder<E, DummyValue> chronicleMapBuilderOnHeap;
ChronicleSetBuilder(Class<E> keyClass) {
chronicleMapBuilder = ChronicleMapBuilder.of(keyClass, DummyValue.class)
chronicleMapBuilderOnHeap = ChronicleMapBuilder.of(keyClass, DummyValue.class)
.valueMarshallers(DummyValueMarshaller.INSTANCE, DummyValueMarshaller.INSTANCE)
.valueSizeMarshaller(DummyValueMarshaller.INSTANCE);
}
@@ -72,7 +72,7 @@ public class ChronicleSetBuilder<E>
try {
@SuppressWarnings("unchecked")
final ChronicleSetBuilder<E> result = (ChronicleSetBuilder<E>) super.clone();
result.chronicleMapBuilder = chronicleMapBuilder.clone();
result.chronicleMapBuilderOnHeap = chronicleMapBuilderOnHeap.clone();
return result;
} catch (CloneNotSupportedException e) {
throw new AssertionError(e);
@@ -81,19 +81,19 @@ public class ChronicleSetBuilder<E>
@Override
public ChronicleSetBuilder<E> actualSegments(int actualSegments) {
chronicleMapBuilder.actualSegments(actualSegments);
chronicleMapBuilderOnHeap.actualSegments(actualSegments);
return this;
}
@Override
public ChronicleSetBuilder<E> minSegments(int minSegments) {
chronicleMapBuilder.minSegments(minSegments);
chronicleMapBuilderOnHeap.minSegments(minSegments);
return this;
}
@Override
public ChronicleSetBuilder<E> actualEntriesPerSegment(long actualEntriesPerSegment) {
chronicleMapBuilder.actualEntriesPerSegment(actualEntriesPerSegment);
chronicleMapBuilderOnHeap.actualEntriesPerSegment(actualEntriesPerSegment);
return this;
}
@@ -116,7 +116,7 @@ public class ChronicleSetBuilder<E>
*/
@Override
public ChronicleSetBuilder<E> keySize(int keySize) {
chronicleMapBuilder.keySize(keySize);
chronicleMapBuilderOnHeap.keySize(keySize);
return this;
}
@@ -132,7 +132,7 @@ public class ChronicleSetBuilder<E>
*/
@Override
public ChronicleSetBuilder<E> constantKeySizeBySample(E sampleKey) {
chronicleMapBuilder.constantKeySizeBySample(sampleKey);
chronicleMapBuilderOnHeap.constantKeySizeBySample(sampleKey);
return this;
}
@@ -149,38 +149,38 @@ public class ChronicleSetBuilder<E>
*/
@Override
public ChronicleSetBuilder<E> entrySize(int entrySize) {
chronicleMapBuilder.entrySize(entrySize);
chronicleMapBuilderOnHeap.entrySize(entrySize);
return this;
}
@Override
public ChronicleSetBuilder<E> entries(long entries) {
chronicleMapBuilder.entries(entries);
chronicleMapBuilderOnHeap.entries(entries);
return this;
}
@Override
public ChronicleSetBuilder<E> lockTimeOut(long lockTimeOut, TimeUnit unit) {
chronicleMapBuilder.lockTimeOut(lockTimeOut, unit);
chronicleMapBuilderOnHeap.lockTimeOut(lockTimeOut, unit);
return this;
}
@Override
public ChronicleSetBuilder<E> errorListener(ChronicleHashErrorListener errorListener) {
chronicleMapBuilder.errorListener(errorListener);
chronicleMapBuilderOnHeap.errorListener(errorListener);
return this;
}
@Override
public ChronicleSetBuilder<E> metaDataBytes(int metaDataBytes) {
chronicleMapBuilder.metaDataBytes(metaDataBytes);
chronicleMapBuilderOnHeap.metaDataBytes(metaDataBytes);
return this;
}
@Override
public String toString() {
return " ChronicleSetBuilder{" +
"chronicleMapBuilder=" + chronicleMapBuilder +
"chronicleMapBuilderOnHeap=" + chronicleMapBuilderOnHeap +
'}';
}
@@ -189,7 +189,7 @@ public class ChronicleSetBuilder<E>
public boolean equals(Object o) {
if (!(o instanceof ChronicleSetBuilder))
return false;
return chronicleMapBuilder.equals(((ChronicleSetBuilder) o).chronicleMapBuilder);
return chronicleMapBuilderOnHeap.equals(((ChronicleSetBuilder) o).chronicleMapBuilderOnHeap);
}
@Override
@@ -199,14 +199,14 @@ public class ChronicleSetBuilder<E>
@Override
public ChronicleSetBuilder<E> timeProvider(TimeProvider timeProvider) {
chronicleMapBuilder.timeProvider(timeProvider);
chronicleMapBuilderOnHeap.timeProvider(timeProvider);
return this;
}
@Override
public ChronicleSetBuilder<E> bytesMarshallerFactory(
BytesMarshallerFactory bytesMarshallerFactory) {
chronicleMapBuilder.bytesMarshallerFactory(bytesMarshallerFactory);
chronicleMapBuilderOnHeap.bytesMarshallerFactory(bytesMarshallerFactory);
return this;
}
@@ -222,26 +222,26 @@ public class ChronicleSetBuilder<E>
*/
@Override
public ChronicleSetBuilder<E> objectSerializer(ObjectSerializer objectSerializer) {
chronicleMapBuilder.objectSerializer(objectSerializer);
chronicleMapBuilderOnHeap.objectSerializer(objectSerializer);
return this;
}
@Override
public ChronicleSetBuilder<E> keyMarshaller(@NotNull BytesMarshaller<E> keyMarshaller) {
chronicleMapBuilder.keyMarshaller(keyMarshaller);
chronicleMapBuilderOnHeap.keyMarshaller(keyMarshaller);
return this;
}
@Override
public ChronicleSetBuilder<E> keyMarshallers(@NotNull BytesWriter<E> keyWriter,
@NotNull BytesReader<E> keyReader) {
chronicleMapBuilder.keyMarshallers(keyWriter, keyReader);
chronicleMapBuilderOnHeap.keyMarshallers(keyWriter, keyReader);
return this;
}
@Override
public ChronicleSetBuilder<E> keySizeMarshaller(@NotNull SizeMarshaller keySizeMarshaller) {
chronicleMapBuilder.keySizeMarshaller(keySizeMarshaller);
chronicleMapBuilderOnHeap.keySizeMarshaller(keySizeMarshaller);
return this;
}
@@ -258,54 +258,54 @@ public class ChronicleSetBuilder<E>
@Override
public ChronicleSetBuilder<E> keyDeserializationFactory(
@NotNull ObjectFactory<E> keyDeserializationFactory) {
chronicleMapBuilder.keyDeserializationFactory(keyDeserializationFactory);
chronicleMapBuilderOnHeap.keyDeserializationFactory(keyDeserializationFactory);
return this;
}
@Override
public ChronicleSetBuilder<E> immutableKeys() {
chronicleMapBuilder.immutableKeys();
chronicleMapBuilderOnHeap.immutableKeys();
return this;
}
@Override
public ChronicleSetBuilder<E> replication(SingleChronicleHashReplication replication) {
chronicleMapBuilder.replication(replication);
chronicleMapBuilderOnHeap.replication(replication);
return this;
}
@Override
public ChronicleSetBuilder<E> replication(byte identifier, TcpTransportAndNetworkConfig tcpTransportAndNetwork) {
chronicleMapBuilder.replication(identifier, tcpTransportAndNetwork);
chronicleMapBuilderOnHeap.replication(identifier, tcpTransportAndNetwork);
return this;
}
@Override
public ChronicleSetBuilder<E> replication(byte identifier) {
chronicleMapBuilder.replication(identifier);
chronicleMapBuilderOnHeap.replication(identifier);
return this;
}
@Override
public StatelessClientConfig<ChronicleSet<E>> statelessClient(
InetSocketAddress remoteAddress) {
return new StatelessSetConfig<>(chronicleMapBuilder.statelessClient(remoteAddress));
return new StatelessSetConfig<>(chronicleMapBuilderOnHeap.statelessClient(remoteAddress));
}
@Override
public ChronicleHashInstanceConfig<ChronicleSet<E>> instance() {
return new InstanceConfig<>(chronicleMapBuilder.instance());
return new InstanceConfig<>(chronicleMapBuilderOnHeap.instance());
}
@Override
public ChronicleSet<E> create() throws IOException {
final ChronicleMap<E, DummyValue> map = chronicleMapBuilder.create();
final ChronicleMap<E, DummyValue> map = chronicleMapBuilderOnHeap.create();
return new SetFromMap<E>(map);
}
@Override
public ChronicleSet<E> createPersistedTo(File file) throws IOException {
ChronicleMap<E, DummyValue> map = chronicleMapBuilder.createPersistedTo(file);
ChronicleMap<E, DummyValue> map = chronicleMapBuilderOnHeap.createPersistedTo(file);
return new SetFromMap<E>(map);
}
src/main/java/net/openhft/chronicle/set/DummyValue.java
+1 -1
View File
@@ -18,6 +18,6 @@
package net.openhft.chronicle.set;
enum DummyValue {
enum DummyValue {
DUMMY_VALUE
}