mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
Clearly separated notion of entries and chunks, averageKeySize()/ValueSize() instead of keySize()/valueSize(), minor fixes and refactorings
This commit is contained in:
@@ -35,7 +35,7 @@ public class TestNesterInterfaceMarshal {
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
.entries(5000L)
|
||||
.keySize(10)
|
||||
.averageKeySize(10)
|
||||
.replication((byte) 1, tcpTransportAndNetworkConfig);
|
||||
|
||||
|
||||
@@ -56,7 +56,7 @@ public class TestNesterInterfaceMarshal {
|
||||
.of(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true)
|
||||
.entries(5000L).keySize(10)
|
||||
.entries(5000L).averageKeySize(10)
|
||||
.replication((byte) 2, tcpTransportAndNetworkConfig1);
|
||||
|
||||
|
||||
@@ -120,7 +120,7 @@ public class TestNesterInterfaceMarshal {
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
.entries(5000L)
|
||||
.keySize(10)
|
||||
.averageKeySize(10)
|
||||
.replication((byte) 1, tcpTransportAndNetworkConfig);
|
||||
|
||||
|
||||
@@ -145,7 +145,7 @@ public class TestNesterInterfaceMarshal {
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true)
|
||||
.entries(5000L)
|
||||
.keySize(10)
|
||||
.averageKeySize(10)
|
||||
.replication((byte) 2, tcpTransportAndNetworkConfig);
|
||||
|
||||
|
||||
|
||||
@@ -186,9 +186,15 @@ public class CHMUseCasesTest {
|
||||
|
||||
map1.getAll(file);
|
||||
|
||||
try (ChronicleMap<Integer, Double> actual = ChronicleMapBuilder.of(map1.keyClass(),
|
||||
VanillaChronicleMap vanillaMap = (VanillaChronicleMap) map1;
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder.of(map1.keyClass(),
|
||||
map1.valueClass())
|
||||
.create()) {
|
||||
.entriesPerSegment(vanillaMap.entriesPerSegment)
|
||||
.actualSegments(vanillaMap.actualSegments)
|
||||
.actualChunksPerSegment(vanillaMap.actualChunksPerSegment);
|
||||
if (!vanillaMap.constantlySizedEntry)
|
||||
builder.actualChunkSize((int) vanillaMap.chunkSize);
|
||||
try (ChronicleMap<Integer, Double> actual = builder.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
|
||||
@@ -211,7 +217,6 @@ public class CHMUseCasesTest {
|
||||
|
||||
private <X, Y> ChronicleMap<X, Y> newInstance(ChronicleMapBuilder<X, Y> builder) throws
|
||||
IOException {
|
||||
|
||||
switch (typeOfMap) {
|
||||
|
||||
case SIMPLE:
|
||||
@@ -378,7 +383,7 @@ public class CHMUseCasesTest {
|
||||
return; // acquireUsingLocked not supported by the STATELESS client
|
||||
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder.of(String.class, BondVOInterface.class)
|
||||
.keySize(10);
|
||||
.averageKeySize(10);
|
||||
|
||||
try (ChronicleMap<String, BondVOInterface> chm = newInstance(builder)) {
|
||||
BondVOInterface bondVO = chm.newValueInstance();
|
||||
@@ -419,7 +424,8 @@ public class CHMUseCasesTest {
|
||||
|
||||
|
||||
@Test
|
||||
public void testOversizedEntry() throws ExecutionException, InterruptedException, IOException {
|
||||
public void testEntrySpanningSeveralChunks()
|
||||
throws ExecutionException, InterruptedException, IOException {
|
||||
|
||||
int salefactor = 100;
|
||||
int valueSize = 10 * salefactor;
|
||||
@@ -429,8 +435,8 @@ public class CHMUseCasesTest {
|
||||
|
||||
ChronicleMapBuilder<CharSequence, char[]> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, char[].class)
|
||||
.keySize(10)
|
||||
.valueSize(10);
|
||||
.averageKeySize(10)
|
||||
.averageValueSize(10);
|
||||
|
||||
try (ChronicleMap<CharSequence, char[]> map = newInstance(builder)) {
|
||||
map.put("Key", expected);
|
||||
@@ -445,8 +451,8 @@ public class CHMUseCasesTest {
|
||||
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.constantKeySizeBySample("Key")
|
||||
.constantValueSizeBySample("Value")
|
||||
.averageKeySize("Key".length())
|
||||
.averageValueSize("Value".length())
|
||||
.entries(1);
|
||||
|
||||
try (ChronicleMap<CharSequence, CharSequence> map = newInstance(builder)) {
|
||||
@@ -974,7 +980,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
try (ChronicleMap<Integer, Integer> map = newInstance(builder)) {
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
Integer key1;
|
||||
Integer key2;
|
||||
Integer value1;
|
||||
@@ -1043,7 +1049,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
try (ChronicleMap<Long, Long> map = newInstance(builder)) {
|
||||
// assertEquals(16, entrySize(map));
|
||||
// assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
// assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
map.put(1L, 11L);
|
||||
assertEquals((Long) 11L, map.get(1L));
|
||||
|
||||
@@ -1097,7 +1103,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
try (ChronicleMap<Double, Double> map = newInstance(builder)) {
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
map.put(1.0, 11.0);
|
||||
assertEquals((Double) 11.0, map.get(1.0));
|
||||
|
||||
@@ -1143,8 +1149,8 @@ public class CHMUseCasesTest {
|
||||
return;
|
||||
|
||||
ChronicleMapBuilder<byte[], byte[]> builder = ChronicleMapBuilder
|
||||
.of(byte[].class, byte[].class).keySize(4).valueSize(4)
|
||||
.maxEntryOversizeFactor(1);
|
||||
.of(byte[].class, byte[].class).averageKeySize(4).averageValueSize(4)
|
||||
.entries(1000);
|
||||
|
||||
try (ChronicleMap<byte[], byte[]> map = newInstance(builder)) {
|
||||
byte[] key1 = {1, 1, 1, 1};
|
||||
@@ -1196,9 +1202,9 @@ public class CHMUseCasesTest {
|
||||
|
||||
ChronicleMapBuilder<ByteBuffer, ByteBuffer> builder = ChronicleMapBuilder
|
||||
.of(ByteBuffer.class, ByteBuffer.class)
|
||||
.keySize(8)
|
||||
.valueSize(8)
|
||||
.maxEntryOversizeFactor(1);
|
||||
.averageKeySize(8)
|
||||
.averageValueSize(8)
|
||||
.entries(1000);
|
||||
|
||||
try (ChronicleMap<ByteBuffer, ByteBuffer> map = newInstance(builder)) {
|
||||
|
||||
@@ -1221,18 +1227,17 @@ public class CHMUseCasesTest {
|
||||
|
||||
|
||||
@Test
|
||||
public void testByteBufferByteBufferMap() throws ExecutionException, InterruptedException, IOException {
|
||||
public void testByteBufferByteBufferMap()
|
||||
throws ExecutionException, InterruptedException, IOException {
|
||||
|
||||
if (typeOfMap == TypeOfMap.STATELESS)
|
||||
return; // getUsingLocked supported by the STATELESS client
|
||||
|
||||
ChronicleMapBuilder<ByteBuffer, ByteBuffer> builder = ChronicleMapBuilder
|
||||
.of(ByteBuffer.class, ByteBuffer.class)
|
||||
.keyMarshaller(ByteBufferMarshaller.INSTANCE)
|
||||
.valueMarshaller(ByteBufferMarshaller.INSTANCE)
|
||||
.keySize(8)
|
||||
.valueSize(8)
|
||||
.maxEntryOversizeFactor(1);
|
||||
.averageKeySize(8)
|
||||
.averageValueSize(8)
|
||||
.entries(1000);
|
||||
|
||||
try (ChronicleMap<ByteBuffer, ByteBuffer> map = newInstance(builder)) {
|
||||
|
||||
@@ -1259,7 +1264,8 @@ public class CHMUseCasesTest {
|
||||
assertBBEquals(ByteBuffer.wrap(new byte[]{11, 11}), map.getMapped(key1, function));
|
||||
assertEquals(null, map.getMapped(key2, function));
|
||||
mapChecks();
|
||||
assertBBEquals(ByteBuffer.wrap(new byte[]{12, 10}), map.putMapped(key1, new UnaryOperator<ByteBuffer>() {
|
||||
assertBBEquals(ByteBuffer.wrap(new byte[]{12, 10}),
|
||||
map.putMapped(key1, new UnaryOperator<ByteBuffer>() {
|
||||
@Override
|
||||
public ByteBuffer update(ByteBuffer s) {
|
||||
s.put(0, (byte) (s.get(0) + 1));
|
||||
@@ -1344,10 +1350,8 @@ public class CHMUseCasesTest {
|
||||
|
||||
ChronicleMapBuilder<ByteBuffer, ByteBuffer> builder = ChronicleMapBuilder
|
||||
.of(ByteBuffer.class, ByteBuffer.class)
|
||||
.valueMarshaller(ByteBufferMarshaller.INSTANCE) // we should not have to to this !
|
||||
.keyMarshaller(ByteBufferMarshaller.INSTANCE) // we should not have to to this !
|
||||
.keySize(5).valueSize(5)
|
||||
.maxEntryOversizeFactor(1);
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
try (ChronicleMap<ByteBuffer, ByteBuffer> map = newInstance(builder)) {
|
||||
|
||||
@@ -1408,7 +1412,7 @@ public class CHMUseCasesTest {
|
||||
try (ChronicleMap<IntValue, IntValue> map = newInstance(builder)) {
|
||||
// this may change due to alignment
|
||||
// assertEquals(8, entrySize(map));
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
IntValue value1 = map.newValueInstance();
|
||||
@@ -1496,7 +1500,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
// this may change due to alignment
|
||||
//assertEquals(8, entrySize(map));
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
UnsignedIntValue key1 = map.newKeyInstance();
|
||||
UnsignedIntValue value1 = map.newValueInstance();
|
||||
|
||||
@@ -1615,7 +1619,7 @@ public class CHMUseCasesTest {
|
||||
// assertEquals(6, entrySize(map));
|
||||
|
||||
|
||||
// assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
// assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
ShortValue value1 = map.newValueInstance();
|
||||
@@ -1707,7 +1711,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
// this may change due to alignment
|
||||
// assertEquals(8, entrySize(map));
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
UnsignedShortValue value1 = map.newValueInstance();
|
||||
@@ -1796,7 +1800,7 @@ public class CHMUseCasesTest {
|
||||
try (ChronicleMap<IntValue, CharValue> map = newInstance(builder)) {
|
||||
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
CharValue value1 = map.newValueInstance();
|
||||
@@ -1887,7 +1891,7 @@ public class CHMUseCasesTest {
|
||||
// TODO should be 5, but shorter fields based on range doesn't seem to be implemented
|
||||
// on data value generation level yet
|
||||
//assertEquals(8, entrySize(map)); this may change due to alignmented
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
@@ -1978,7 +1982,7 @@ public class CHMUseCasesTest {
|
||||
try (ChronicleMap<IntValue, BooleanValue> map = newInstance(builder)) {
|
||||
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
|
||||
IntValue key1 = map.newKeyInstance();
|
||||
IntValue key2 = map.newKeyInstance();
|
||||
@@ -2069,7 +2073,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
try (ChronicleMap<FloatValue, FloatValue> map = newInstance(builder)) {
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
|
||||
FloatValue key1 = map.newKeyInstance();
|
||||
FloatValue key2 = map.newKeyInstance();
|
||||
@@ -2163,7 +2167,7 @@ public class CHMUseCasesTest {
|
||||
// this may change due to alignment
|
||||
//assertEquals(16, entrySize(map));
|
||||
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
|
||||
DoubleValue key1 = map.newKeyInstance();
|
||||
DoubleValue key2 = map.newKeyInstance();
|
||||
@@ -2258,7 +2262,7 @@ public class CHMUseCasesTest {
|
||||
|
||||
// this may change due to alignment
|
||||
// assertEquals(16, entrySize(map));
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxEntryOversizeFactor);
|
||||
assertEquals(1, ((VanillaChronicleMap) map).maxChunksPerEntry);
|
||||
|
||||
LongValue key1 = map.newKeyInstance();
|
||||
LongValue key2 = map.newKeyInstance();
|
||||
@@ -2536,7 +2540,7 @@ public class CHMUseCasesTest {
|
||||
return; // acquireUsingLocked not supported by the STATELESS client
|
||||
|
||||
ChronicleMapBuilder<String, IBean> builder = ChronicleMapBuilder
|
||||
.of(String.class, IBean.class).keySize(5);
|
||||
.of(String.class, IBean.class).averageKeySize(5).entries(1000);
|
||||
try (ChronicleMap<String, IBean> map = newInstance(builder)) {
|
||||
|
||||
IBean iBean = map.newValueInstance();
|
||||
|
||||
@@ -32,16 +32,16 @@ public class ChronicleMapImportExportTest {
|
||||
File file = new File(TMP + "/chronicle-map-" + System.nanoTime() + ".json");
|
||||
file.deleteOnExit();
|
||||
|
||||
try (ChronicleMap<String, String> expected = ChronicleMapBuilder.of(String.class, String
|
||||
.class)
|
||||
.create()) {
|
||||
ChronicleMapBuilder<String, String> builder = ChronicleMapBuilder
|
||||
.of(String.class, String.class)
|
||||
.averageKeySize(10).averageValueSize(10)
|
||||
.entries(1000);
|
||||
try (ChronicleMap<String, String> expected = builder.create()) {
|
||||
expected.put("hello", "world");
|
||||
expected.put("aKey", "aValue");
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<String, String> actual = ChronicleMapBuilder.of(String.class, String
|
||||
.class)
|
||||
.create()) {
|
||||
try (ChronicleMap<String, String> actual = builder.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
Assert.assertEquals(expected, actual);
|
||||
@@ -58,17 +58,19 @@ public class ChronicleMapImportExportTest {
|
||||
file.deleteOnExit();
|
||||
|
||||
System.out.println(file.getAbsoluteFile());
|
||||
try (ChronicleMap<String, Map> expected = ChronicleMapBuilder.of(String.class, Map
|
||||
.class)
|
||||
ChronicleMapBuilder<String, Map> builder = ChronicleMapBuilder
|
||||
.of(String.class, Map.class)
|
||||
.averageKeySize("hello".length())
|
||||
.averageValueSize(100)
|
||||
.entries(1000);
|
||||
try (ChronicleMap<String, Map> expected = builder
|
||||
.create()) {
|
||||
HashMap<String, String> data = new HashMap<>();
|
||||
data.put("myKey", "myValue");
|
||||
expected.put("hello", data);
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<String, Map> actual = ChronicleMapBuilder.of(String.class, Map
|
||||
.class)
|
||||
.create()) {
|
||||
try (ChronicleMap<String, Map> actual = builder.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
Assert.assertEquals(expected, actual);
|
||||
@@ -85,8 +87,10 @@ public class ChronicleMapImportExportTest {
|
||||
file.deleteOnExit();
|
||||
|
||||
System.out.println(file.getAbsoluteFile());
|
||||
try (ChronicleMap expected = ChronicleMapBuilder.of
|
||||
(String.class, Map.class).create()) {
|
||||
ChronicleMapBuilder<String, Map> builder = ChronicleMapBuilder
|
||||
.of(String.class, Map.class)
|
||||
.averageKeySize("hello".length()).averageValueSize(100).entries(1000);
|
||||
try (ChronicleMap expected = builder.create()) {
|
||||
HashMap<String, Map> data = new HashMap<>();
|
||||
HashMap<String, String> data2 = new HashMap<>();
|
||||
data2.put("nested", "map");
|
||||
@@ -95,8 +99,7 @@ public class ChronicleMapImportExportTest {
|
||||
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<String, Map> actual = ChronicleMapBuilder.of(String.class, Map
|
||||
.class)
|
||||
try (ChronicleMap<String, Map> actual = builder
|
||||
.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
@@ -139,15 +142,17 @@ public class ChronicleMapImportExportTest {
|
||||
file.deleteOnExit();
|
||||
|
||||
System.out.println(file.getAbsolutePath());
|
||||
try (ChronicleMap<CharSequence, CharSequence> expected = ChronicleMapBuilder.of(CharSequence.class, CharSequence
|
||||
.class)
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize("hello".length()).averageValueSize("world".length())
|
||||
.entries(1000);
|
||||
try (ChronicleMap<CharSequence, CharSequence> expected = builder
|
||||
.create()) {
|
||||
expected.put("hello", "world");
|
||||
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<CharSequence, CharSequence> actual = ChronicleMapBuilder.of(CharSequence.class, CharSequence
|
||||
.class)
|
||||
try (ChronicleMap<CharSequence, CharSequence> actual = builder
|
||||
.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
@@ -179,8 +184,11 @@ public class ChronicleMapImportExportTest {
|
||||
xstream.toXML(map, new FileOutputStream(file));
|
||||
|
||||
|
||||
try (ChronicleMap<Integer, String> expected = ChronicleMapBuilder.of(Integer.class,
|
||||
String.class).create()) {
|
||||
try (ChronicleMap<Integer, String> expected = ChronicleMapBuilder
|
||||
.of(Integer.class, String.class)
|
||||
.averageValueSize(10)
|
||||
.entries(1000)
|
||||
.create()) {
|
||||
|
||||
expected.put(1, "one");
|
||||
expected.put(2, "two");
|
||||
@@ -233,9 +241,11 @@ public class ChronicleMapImportExportTest {
|
||||
//file.deleteOnExit();
|
||||
|
||||
System.out.println(file.getAbsolutePath());
|
||||
try (ChronicleMap<CharSequence, LongValue> expected = ChronicleMapBuilder.of(CharSequence.class, LongValue
|
||||
.class)
|
||||
.create()) {
|
||||
ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, LongValue.class)
|
||||
.averageKeySize("one".length())
|
||||
.entries(1000);
|
||||
try (ChronicleMap<CharSequence, LongValue> expected = builder.create()) {
|
||||
LongValue value = expected.newValueInstance();
|
||||
|
||||
// this will add the entry
|
||||
@@ -248,9 +258,7 @@ public class ChronicleMapImportExportTest {
|
||||
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<CharSequence, LongValue> actual = ChronicleMapBuilder.of(CharSequence.class, LongValue
|
||||
.class)
|
||||
.create()) {
|
||||
try (ChronicleMap<CharSequence, LongValue> actual = builder.create()) {
|
||||
|
||||
actual.putAll(file);
|
||||
|
||||
@@ -269,8 +277,11 @@ public class ChronicleMapImportExportTest {
|
||||
file.deleteOnExit();
|
||||
|
||||
System.out.println(file.getAbsolutePath());
|
||||
ChronicleMapBuilder<CharSequence, BondVOInterface> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, BondVOInterface.class)
|
||||
.averageKeySize("one".length()).entries(1000);
|
||||
try (ChronicleMap<CharSequence, BondVOInterface> expected =
|
||||
ChronicleMapBuilder.of(CharSequence.class, BondVOInterface.class).create()) {
|
||||
builder.create()) {
|
||||
|
||||
final BondVOInterface value = expected.newValueInstance();
|
||||
|
||||
@@ -286,13 +297,12 @@ public class ChronicleMapImportExportTest {
|
||||
|
||||
expected.getAll(file);
|
||||
|
||||
try (ChronicleMap<CharSequence, BondVOInterface> actual =
|
||||
ChronicleMapBuilder.of(CharSequence.class,
|
||||
DataValueClasses.directClassFor(BondVOInterface.class)).create()) {
|
||||
try (ChronicleMap<CharSequence, BondVOInterface> actual = builder.create()) {
|
||||
|
||||
actual.putAll(file);
|
||||
|
||||
Assert.assertEquals(expected.get("one").getCoupon(), actual.get("one").getCoupon(), 0);
|
||||
Assert.assertEquals(expected.get("one").getCoupon(),
|
||||
actual.get("one").getCoupon(), 0);
|
||||
}
|
||||
} finally {
|
||||
file.delete();
|
||||
|
||||
@@ -108,7 +108,7 @@ public class ChronicleMapTest {
|
||||
return ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
|
||||
.entries(entries)
|
||||
.minSegments(segments)
|
||||
.keySize(keySize)
|
||||
.averageKeySize(keySize)
|
||||
.entryAndValueAlignment(alignment)
|
||||
.create();
|
||||
}
|
||||
@@ -653,7 +653,7 @@ public class ChronicleMapTest {
|
||||
.entries(entries)
|
||||
.actualSegments(8 * 1024)
|
||||
.entryAndValueAlignment(OF_8_BYTES)
|
||||
.keySize(13);
|
||||
.averageKeySize(13);
|
||||
|
||||
File tmpFile = File.createTempFile("testAcquirePerf", ".deleteme");
|
||||
tmpFile.deleteOnExit();
|
||||
@@ -728,7 +728,7 @@ public class ChronicleMapTest {
|
||||
.entries(entries)
|
||||
.entryAndValueAlignment(OF_8_BYTES)
|
||||
.actualSegments(256)
|
||||
.keySize(13);
|
||||
.averageKeySize(13);
|
||||
|
||||
File tmpFile = File.createTempFile("testAcquirePerf", ".deleteme");
|
||||
tmpFile.deleteOnExit();
|
||||
@@ -936,8 +936,8 @@ public class ChronicleMapTest {
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(entries)
|
||||
.minSegments(16)
|
||||
.keySize("user:".length() + 6)
|
||||
.valueSize("value:".length() + 6)
|
||||
.averageKeySize("user:".length() + 6)
|
||||
.averageValueSize("value:".length() + 6)
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true).create();
|
||||
StringBuilder key = new StringBuilder();
|
||||
@@ -1365,7 +1365,7 @@ public class ChronicleMapTest {
|
||||
ChronicleMap<Integer, CharSequence> map =
|
||||
ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.entries(noOfElements * 2 + 100)
|
||||
.valueSize((noOfElements + "").length())
|
||||
.averageValueSize((noOfElements + "").length())
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true).create();
|
||||
|
||||
@@ -1382,52 +1382,52 @@ public class ChronicleMapTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOversizeEntriesPutRemoveReplace() throws IOException {
|
||||
public void testEntriesSpanningSeveralChunksPutRemoveReplace() throws IOException {
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(10)
|
||||
.minSegments(1)
|
||||
.entrySize(10);
|
||||
testOversizeEntriesPutRemoveReplace(
|
||||
.actualChunkSize(10);
|
||||
testEntriesSpanningSeveralChunksPutRemoveReplace(
|
||||
(VanillaChronicleMap<CharSequence, ?, ?, CharSequence, ?, ?>)
|
||||
builder.createPersistedTo(getPersistenceFile())
|
||||
);
|
||||
}
|
||||
|
||||
public void testOversizeEntriesPutRemoveReplace(
|
||||
public void testEntriesSpanningSeveralChunksPutRemoveReplace(
|
||||
VanillaChronicleMap<CharSequence, ?, ?, CharSequence, ?, ?> map) {
|
||||
String key = "k";
|
||||
String oversizedKey = "oversized key";
|
||||
String largeKey = "very large key";
|
||||
String value = "v";
|
||||
String oversizedValue = "oversized value";
|
||||
String largeValue = "vary large value";
|
||||
|
||||
map.put(key, oversizedValue);
|
||||
assertEquals(oversizedValue, map.get(key));
|
||||
map.put(key, largeValue);
|
||||
assertEquals(largeValue, map.get(key));
|
||||
map.replace(key, value);
|
||||
map.checkConsistency();
|
||||
assertEquals(value, map.get(key));
|
||||
map.replace(key, oversizedValue);
|
||||
map.replace(key, largeValue);
|
||||
map.checkConsistency();
|
||||
assertEquals(oversizedValue, map.get(key));
|
||||
assertEquals(largeValue, map.get(key));
|
||||
|
||||
map.put(oversizedKey, value);
|
||||
map.put(largeKey, value);
|
||||
map.checkConsistency();
|
||||
assertEquals(value, map.get(oversizedKey));
|
||||
map.replace(oversizedKey, oversizedValue);
|
||||
assertEquals(value, map.get(largeKey));
|
||||
map.replace(largeKey, largeValue);
|
||||
map.checkConsistency();
|
||||
assertEquals(oversizedValue, map.get(oversizedKey));
|
||||
map.remove(oversizedKey);
|
||||
assertEquals(largeValue, map.get(largeKey));
|
||||
map.remove(largeKey);
|
||||
map.checkConsistency();
|
||||
assertEquals(null, map.get(oversizedKey));
|
||||
map.put(oversizedKey, oversizedValue);
|
||||
assertEquals(null, map.get(largeKey));
|
||||
map.put(largeKey, largeValue);
|
||||
map.checkConsistency();
|
||||
assertEquals(oversizedValue, map.get(oversizedKey));
|
||||
map.replace(oversizedKey, oversizedValue, value);
|
||||
assertEquals(largeValue, map.get(largeKey));
|
||||
map.replace(largeKey, largeValue, value);
|
||||
map.checkConsistency();
|
||||
assertEquals(value, map.get(oversizedKey));
|
||||
assertEquals(value, map.get(largeKey));
|
||||
|
||||
assertEquals(value, map.remove(oversizedKey));
|
||||
assertEquals(value, map.remove(largeKey));
|
||||
map.checkConsistency();
|
||||
assertEquals(oversizedValue, map.remove(key));
|
||||
assertEquals(largeValue, map.remove(key));
|
||||
map.checkConsistency();
|
||||
|
||||
map.close();
|
||||
@@ -1488,7 +1488,7 @@ public class ChronicleMapTest {
|
||||
final ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, LongValue.class)
|
||||
.entries(1000)
|
||||
.keySize("x".length());
|
||||
.averageKeySize("x".length());
|
||||
|
||||
final ChronicleMap<CharSequence, LongValue> map = builder.create();
|
||||
|
||||
@@ -1501,7 +1501,7 @@ public class ChronicleMapTest {
|
||||
ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, LongValue.class)
|
||||
.entries(1000)
|
||||
.keySize("one".length());
|
||||
.averageKeySize("one".length());
|
||||
|
||||
final ChronicleMap<CharSequence, LongValue> map = builder.create();
|
||||
|
||||
@@ -1575,8 +1575,8 @@ public class ChronicleMapTest {
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.entries(1000)
|
||||
.keySize("one".length())
|
||||
.valueSize("Hello World".length())
|
||||
.averageKeySize("one".length())
|
||||
.averageValueSize("Hello World".length())
|
||||
.defaultValue("")
|
||||
.create()) {
|
||||
StringBuilder value = new StringBuilder();
|
||||
@@ -1594,7 +1594,7 @@ public class ChronicleMapTest {
|
||||
ChronicleMapBuilder<CharSequence, LongValue> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, LongValue.class)
|
||||
.entries(1000)
|
||||
.keySize("one".length());
|
||||
.averageKeySize("one".length());
|
||||
File tmpFile = File.createTempFile("testAcquireUsingLocked", ".deleteme");
|
||||
tmpFile.deleteOnExit();
|
||||
final ChronicleMap<CharSequence, LongValue> map = builder.createPersistedTo(tmpFile);
|
||||
|
||||
@@ -32,11 +32,9 @@ import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
|
||||
import static java.lang.Math.log10;
|
||||
import static java.lang.Math.round;
|
||||
import static net.openhft.chronicle.map.Alignment.OF_4_BYTES;
|
||||
import static net.openhft.lang.model.DataValueClasses.newDirectReference;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.fail;
|
||||
@@ -58,8 +56,7 @@ public class EntryCountMapTest {
|
||||
ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
|
||||
.entries(entries)
|
||||
.actualSegments(segments)
|
||||
.keySize(keySize)
|
||||
.maxEntryOversizeFactor(1);
|
||||
.averageKeySize(keySize);
|
||||
return mapBuilder.createPersistedTo(getPersistenceFile());
|
||||
}
|
||||
|
||||
|
||||
@@ -100,6 +100,7 @@ public class GuavaTest extends TestCase {
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(100)
|
||||
.averageKeySize(10).averageValueSize(10)
|
||||
.minSegments(2);
|
||||
|
||||
@Override
|
||||
|
||||
@@ -34,8 +34,8 @@ public class Issue42Test {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.entrySize(18)
|
||||
.entries(1500000)
|
||||
.averageKeySize(5.9).averageValueSize(5.9)
|
||||
.entries(1000000)
|
||||
.minSegments(128).create()) {
|
||||
for (int i = 0; i < 1000000; ++i) {
|
||||
String s = String.valueOf(i);
|
||||
|
||||
@@ -53,7 +53,8 @@ public class LargeEntriesTest {
|
||||
.valueMarshaller(SnappyStringMarshaller.INSTANCE)
|
||||
.actualSegments(1) // to force an error.
|
||||
.entries(ENTRIES)
|
||||
.entrySize(ENTRY_SIZE / 6)
|
||||
.averageKeySize(10)
|
||||
.averageValueSize(ENTRY_SIZE)
|
||||
.putReturnsNull(true)
|
||||
.createPersistedTo(file);
|
||||
{
|
||||
@@ -69,7 +70,8 @@ public class LargeEntriesTest {
|
||||
futureList.add(es.submit(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
exerciseLargeStrings(map, finalT * block, finalT * block + block, ENTRY_SIZE);
|
||||
exerciseLargeStrings(map, finalT * block, finalT * block + block,
|
||||
ENTRY_SIZE);
|
||||
}
|
||||
}));
|
||||
}
|
||||
@@ -78,7 +80,8 @@ public class LargeEntriesTest {
|
||||
}
|
||||
long time = System.currentTimeMillis() - start;
|
||||
long operations = 3;
|
||||
System.out.printf("Put/Get rate was %.1f MB/s%n", operations * ENTRIES * ENTRY_SIZE / 1e6 / (time / 1e3));
|
||||
System.out.printf("Put/Get rate was %.1f MB/s%n",
|
||||
operations * ENTRIES * ENTRY_SIZE / 1e6 / (time / 1e3));
|
||||
}
|
||||
es.shutdown();
|
||||
if (es.isTerminated())
|
||||
@@ -117,7 +120,8 @@ public class LargeEntriesTest {
|
||||
.of(String.class, String.class)
|
||||
.valueMarshaller(SnappyStringMarshaller.INSTANCE)
|
||||
.entries(ENTRIES)
|
||||
.entrySize(ENTRY_SIZE / 7 + 200)
|
||||
.averageKeySize(10)
|
||||
.averageValueSize(ENTRY_SIZE)
|
||||
.putReturnsNull(true)
|
||||
.createPersistedTo(file);
|
||||
{
|
||||
@@ -133,7 +137,8 @@ public class LargeEntriesTest {
|
||||
futureList.add(es.submit(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
exerciseLargeStrings(map, finalT * block, finalT * block + block, ENTRY_SIZE);
|
||||
exerciseLargeStrings(map, finalT * block, finalT * block + block,
|
||||
ENTRY_SIZE);
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -49,7 +49,7 @@ public class MapByNameTest {
|
||||
final MapInstanceConfig<CharSequence, CharSequence> config =
|
||||
(MapInstanceConfig<CharSequence, CharSequence>)
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.keySize("hello".length()).valueSize("world".length())
|
||||
.averageKeySize("hello".length()).averageValueSize("world".length())
|
||||
.entries(2)
|
||||
.minSegments(2)
|
||||
.replication((byte) 1, TcpTransportAndNetworkConfig.of(8244))
|
||||
|
||||
@@ -69,12 +69,10 @@ public class MarkTest {
|
||||
private static void test(Function<ChronicleMapBuilder<Integer, Integer>,
|
||||
ChronicleMap<Integer, Integer>> createMap) {
|
||||
long ms = System.currentTimeMillis();
|
||||
double entriesWithMargin = ENTRIES * 1.1;
|
||||
long actualEntriesPerSegment = (1L << 17) / 3L;
|
||||
try (ChronicleMap<Integer, Integer> map = createMap.apply(ChronicleMapBuilder
|
||||
.of(Integer.class, Integer.class)
|
||||
.actualSegments((int) (entriesWithMargin / actualEntriesPerSegment))
|
||||
.actualEntriesPerSegment(actualEntriesPerSegment)
|
||||
.entries(ENTRIES)
|
||||
.entriesPerSegment((1 << 17) / 3)
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true))) {
|
||||
|
||||
|
||||
+3
-3
@@ -19,13 +19,13 @@ package net.openhft.chronicle.map;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class NoEntryOversizeFactorTest {
|
||||
public class NoUpperBoundChunksPerEntryTest {
|
||||
|
||||
@Test
|
||||
public void noOversizeFactorTest() {
|
||||
public void noUpperBoundChunksPerEntryTest() {
|
||||
ChronicleMap<Integer, CharSequence> map =
|
||||
ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.valueSize(1).entries(10000L).actualSegments(1).create();
|
||||
.averageValueSize(1).entries(10000L).actualSegments(1).create();
|
||||
String ultraLargeValue = "";
|
||||
for (int i = 0; i < 100; i++) {
|
||||
ultraLargeValue += "Hello";
|
||||
@@ -36,7 +36,7 @@ public class OSResizesMain {
|
||||
byte[] chars = new byte[valueSize];
|
||||
ByteArray ba = new ByteArray(chars);
|
||||
ChronicleMap<String, ByteArray> map = ChronicleMapBuilder.of(String.class, ByteArray.class)
|
||||
.keySize("key-".length() + 4)
|
||||
.averageKeySize("key-".length() + 4)
|
||||
.constantValueSizeBySample(ba)
|
||||
.createPersistedTo(file);
|
||||
Arrays.fill(chars, (byte) '+');
|
||||
|
||||
@@ -656,15 +656,15 @@ public class StatelessClientTest {
|
||||
|
||||
try (ChronicleMap<byte[], byte[]> serverMap = ChronicleMapBuilder
|
||||
.of(byte[].class, byte[].class)
|
||||
.keySize(4)
|
||||
.valueSize(4)
|
||||
.averageKeySize(4)
|
||||
.averageValueSize(4)
|
||||
.replication((byte) 2, TcpTransportAndNetworkConfig.of(8056))
|
||||
.create()) {
|
||||
|
||||
try (ChronicleMap<byte[], byte[]> statelessMap = ChronicleMapBuilder
|
||||
.of(byte[].class, byte[].class)
|
||||
.keySize(4)
|
||||
.valueSize(4)
|
||||
.averageKeySize(4)
|
||||
.averageValueSize(4)
|
||||
.statelessClient(new InetSocketAddress("localhost", 8056))
|
||||
.create()) {
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@ public class TCPSocketReplication4WayMapTest {
|
||||
final int serverPort,
|
||||
final InetSocketAddress... endpoints) throws IOException {
|
||||
return (T) newTcpSocketShmBuilder(Integer.class, CharSequence.class,
|
||||
identifier, serverPort, endpoints).create();
|
||||
identifier, serverPort, endpoints).averageValueSize(10).create();
|
||||
}
|
||||
|
||||
@Before
|
||||
|
||||
+4
-4
@@ -80,7 +80,7 @@ public class TcpReplicationWithAcquireUsingLockedTest {
|
||||
(CharSequence.class,
|
||||
TestInstrumentVOInterface
|
||||
.class)
|
||||
.entries(5000L).keySize("hello".length())
|
||||
.entries(5000L).averageKeySize("hello".length())
|
||||
.replication((byte) 1, config1).create()) {
|
||||
|
||||
map1a = map1;
|
||||
@@ -95,7 +95,7 @@ public class TcpReplicationWithAcquireUsingLockedTest {
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true)
|
||||
.replication((byte) 2, config2)
|
||||
.entries(5000L).keySize("hello".length()).create()) {
|
||||
.entries(5000L).averageKeySize("hello".length()).create()) {
|
||||
|
||||
map2a = map2;
|
||||
|
||||
@@ -133,7 +133,7 @@ public class TcpReplicationWithAcquireUsingLockedTest {
|
||||
(CharSequence.class,
|
||||
TestInstrumentVOInterface
|
||||
.class)
|
||||
.entries(5000L).keySize("hello".length())
|
||||
.entries(5000L).averageKeySize("hello".length())
|
||||
.replication((byte) 1, config1).create()) {
|
||||
|
||||
map1a = map1;
|
||||
@@ -148,7 +148,7 @@ public class TcpReplicationWithAcquireUsingLockedTest {
|
||||
.putReturnsNull(true)
|
||||
.removeReturnsNull(true)
|
||||
.replication((byte) 2, config2)
|
||||
.entries(5000L).keySize("hello".length()).create()) {
|
||||
.entries(5000L).averageKeySize("hello".length()).create()) {
|
||||
|
||||
map2a = map2;
|
||||
|
||||
|
||||
+11
-8
@@ -15,16 +15,17 @@ import static org.junit.Assert.assertEquals;
|
||||
/**
|
||||
* @author Rob Austin.
|
||||
*/
|
||||
public class TestOversizedReplicationHub {
|
||||
public class TestEntriesSpanningSeveralChunksReplicationHub {
|
||||
|
||||
@Test
|
||||
public void testReplicationHubHandlesOverSizeEntries() throws IOException, InterruptedException {
|
||||
public void testReplicationHubHandlesSpanningSeveralChunksEntries()
|
||||
throws IOException, InterruptedException {
|
||||
|
||||
ChronicleMap<CharSequence, CharSequence> favoriteColourServer1, favoriteColourServer2;
|
||||
ChronicleMap<CharSequence, CharSequence> favoriteComputerServer1, favoriteComputerServer2;
|
||||
|
||||
int OVERSIZE_FACTOR = 65;
|
||||
char[] largeEntry = new char[100 * OVERSIZE_FACTOR];
|
||||
int chunksPerEntry = 65;
|
||||
char[] largeEntry = new char[100 * chunksPerEntry];
|
||||
|
||||
Arrays.fill(largeEntry, 'X');
|
||||
String largeString = new String(largeEntry);
|
||||
@@ -33,8 +34,9 @@ public class TestOversizedReplicationHub {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.keySize(10)
|
||||
.valueSize(100);
|
||||
.averageKeySize(10)
|
||||
.averageValueSize(100)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 1;
|
||||
|
||||
@@ -68,8 +70,9 @@ public class TestOversizedReplicationHub {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.keySize(10)
|
||||
.valueSize(100);
|
||||
.averageKeySize(10)
|
||||
.averageValueSize(100)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 2;
|
||||
|
||||
@@ -28,21 +28,11 @@ public class LotsOfEntriesMain {
|
||||
throws IOException, ExecutionException, InterruptedException {
|
||||
final long entries = 100_000_000;
|
||||
File file = new File("/tmp/lotsOfEntries.dat");
|
||||
double averageEntrySize =
|
||||
1 + // key size marshalling size
|
||||
// + 2 is average oversize because we append 4-letter "-key" in a loop
|
||||
(Math.log(1.024) - Math.log(0.024)) * 24 + 2 + // average key size
|
||||
24 + // value size
|
||||
2 // average loss due to value alignment. defaults to OF_4_BYTES because
|
||||
// there are floats in values
|
||||
;
|
||||
final ChronicleMap<CharSequence, MyFloats> map = ChronicleMapBuilder
|
||||
.of(CharSequence.class, MyFloats.class)
|
||||
.entries((long) (entries *
|
||||
(averageEntrySize / 8.0 +
|
||||
0.5))) // account average internal fragmentation --
|
||||
// because we need to round up to integral number of chunks
|
||||
.entrySize(8) // "chunk mode"
|
||||
.entries(entries)
|
||||
// + 2 is average oversize because we append 4-letter "-key" in a loop
|
||||
.averageKeySize((Math.log(1.024) - Math.log(0.024)) * 24 + 2)
|
||||
.createPersistedTo(file);
|
||||
int threads = Runtime.getRuntime().availableProcessors();
|
||||
ExecutorService es = Executors.newFixedThreadPool(threads);
|
||||
|
||||
@@ -41,9 +41,10 @@ public class StringsMapMain {
|
||||
int keyAndValueSize = (int) Math.round(Math.log10(entries));
|
||||
final ChronicleMap<CharSequence, CharSequence> serverMap = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.entries(entries)
|
||||
.putReturnsNull(true)
|
||||
.keySize(keyAndValueSize)
|
||||
.valueSize(keyAndValueSize)
|
||||
.averageKeySize(keyAndValueSize)
|
||||
.averageValueSize(keyAndValueSize)
|
||||
.replication((byte) 2, TcpTransportAndNetworkConfig.of(port))
|
||||
.createPersistedTo(file);
|
||||
System.out.println("Server started");
|
||||
|
||||
@@ -56,7 +56,8 @@ public class OpenJDKAndHashMapExamplesTest {
|
||||
|
||||
ChronicleMap<String, BondVOInterface> chm = ChronicleMapBuilder
|
||||
.of(String.class, BondVOInterface.class)
|
||||
.keySize(10)
|
||||
.averageKeySize(10)
|
||||
.entries(1000)
|
||||
.createPersistedTo(file);
|
||||
|
||||
BondVOInterface bondVO = chm.newValueInstance();
|
||||
@@ -76,7 +77,8 @@ public class OpenJDKAndHashMapExamplesTest {
|
||||
|
||||
ChronicleMap<String, BondVOInterface> chmB = ChronicleMapBuilder
|
||||
.of(String.class, BondVOInterface.class)
|
||||
.keySize(10)
|
||||
.averageKeySize(10)
|
||||
.entries(1000)
|
||||
.createPersistedTo(file);
|
||||
|
||||
// ZERO Copy but creates a new off heap reference each time
|
||||
|
||||
@@ -193,7 +193,7 @@ public class StringEncodingExamplesTest {
|
||||
try (ChronicleSet<CharSequence> chineseWordSet = ChronicleSetBuilder.of(CharSequence.class)
|
||||
.keyMarshaller(marshaller)
|
||||
.actualSegments(1)
|
||||
.actualEntriesPerSegment(1000)
|
||||
.entriesPerSegment(1000)
|
||||
.create()) {
|
||||
chineseWordSet.add("新闻");
|
||||
chineseWordSet.add("地图");
|
||||
|
||||
+1
-1
@@ -92,6 +92,6 @@ public class PingPongCASLeft {
|
||||
AffinitySupport.setThreadId();
|
||||
return ChronicleMapBuilder.of(String.class, BondVOInterface.class)
|
||||
.entries(16)
|
||||
.keySize("369604101".length()).create();
|
||||
.averageKeySize("369604101".length()).create();
|
||||
}
|
||||
}
|
||||
@@ -41,6 +41,7 @@ public class ChronicleMapTest extends JSR166TestCase {
|
||||
|
||||
static ChronicleMap<Integer, CharSequence> newShmIntString(int size) throws IOException {
|
||||
return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(1)
|
||||
.entries(size).create();
|
||||
}
|
||||
|
||||
|
||||
@@ -234,6 +234,7 @@ public class StatelessChronicleMapTest extends JSR166TestCase {
|
||||
|
||||
final ChronicleMap<Integer, String> serverMap =
|
||||
ChronicleMapBuilder.of(Integer.class, String.class)
|
||||
.averageValueSize(1)
|
||||
.entries(SIZE)
|
||||
.replication((byte) 1, TcpTransportAndNetworkConfig.of(port))
|
||||
.create();
|
||||
|
||||
@@ -137,7 +137,7 @@ public class ProcessInstanceLimiter implements Runnable {
|
||||
ChronicleMapBuilder<String, Data> builder =
|
||||
ChronicleMapBuilder.of(String.class, Data.class);
|
||||
builder.entries(1000);
|
||||
builder.keySize((DEFAULT_PROCESS_NAME + "#").length());
|
||||
builder.averageKeySize((DEFAULT_PROCESS_NAME + "#").length());
|
||||
this.theSharedMap = builder.createPersistedTo(new File(sharedMapPath));
|
||||
Thread t = new Thread(this, "ProcessInstanceLimiter updater");
|
||||
t.setDaemon(true);
|
||||
|
||||
@@ -29,7 +29,7 @@ public class Issue3Test {
|
||||
public void test() throws IOException {
|
||||
try (ChronicleSet<Long> set = ChronicleSetBuilder.of(Long.class)
|
||||
.actualSegments(1)
|
||||
.actualEntriesPerSegment(1000)
|
||||
.entriesPerSegment(1000)
|
||||
.create()) {
|
||||
Random r = new Random();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
|
||||
Reference in New Issue
Block a user