Add support for readWriteLocks. Reads are re-entrant but not writes.

src/main/java/net/openhft/chronicle/map/ChronicleMapBuilder.java

@@ -59,26 +59,26 @@ import static net.openhft.chronicle.map.Objects.builderEquals;
  * ChronicleMapBuilder<Key, Value> builder = ChronicleMapBuilder
  *     .of(Key.class, Value.class)
  *     .entries(100500);
- *
+ * <p/>
  * ChronicleMap<Key, Value> map1 = builder.create();
  * ChronicleMap<Key, Value> map2 = builder.create();}</pre>
  * i. e. created {@code ChronicleMap} instances don't depend on the builder.
- *
+ * <p/>
  * <p>Use static {@link #of(Class, Class)} method to obtain a {@code ChronicleMapBuilder} instance.
- *
+ * <p/>
  * <p>{@code ChronicleMapBuilder} is mutable. Configuration methods mutate the builder and return <i>the
  * builder itself</i> back to support chaining pattern, rather than the builder copies with the corresponding
  * configuration changed. To make an independent configuration, {@linkplain #clone} the builder.
- *
+ * <p/>
  * <p>Later in this documentation, "ChronicleMap" means "ChronicleMaps, created by {@code
  * ChronicleMapBuilder}", unless specified different, because theoretically someone might provide {@code
  * ChronicleMap} implementations with completely different properties.
- *
+ * <p/>
  * <p>{@code ChronicleMap} ("ChronicleMaps, created by {@code ChronicleMapBuilder}") currently doesn't support
  * resizing. That is why you should <i>always</i> configure {@linkplain #entries(long) number of entries} you
  * are going to insert into the created map <i>at most</i>. See {@link #entries(long)} method documentation
  * for more information on this.
- *
+ * <p/>
  * <p>{@code ChronicleMap} allocates memory by equally sized chunks. This size is called {@linkplain
  * #entrySize(int) entry size}, you are strongly recommended to configure it to achieve least memory
  * consumption and best speed. See {@link #entrySize(int)} method documentation for more information on this.
@@ -179,7 +179,7 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
 
     /**
      * {@inheritDoc}
-     *
+     * <p/>
      * <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 = ChronicleMapBuilder
@@ -206,7 +206,7 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
 
     /**
      * {@inheritDoc}
-     *
+     * <p/>
      * <p>For example, if your keys are Git commit hashes:<pre>{@code
      * Map<byte[], String> gitCommitMessagesByHash =
      *     ChronicleMapBuilder.of(byte[].class, String.class)
@@ -230,10 +230,10 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
      * 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/>
      * <p>If value is a boxed primitive type or {@link Byteable} subclass, i. e. if value size is known
      * statically, it is automatically accounted and shouldn't be specified by user.
-     *
+     * <p/>
      * <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.
@@ -254,10 +254,10 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
      * 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/>
      * <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/>
      * <p>If value size varies, method {@link #valueSize(int)} or {@link #entrySize(int)} should be called
      * instead of this one.
      *
@@ -286,16 +286,16 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
 
     /**
      * {@inheritDoc}
-     *
+     * <p/>
      * <p>In fully default case you can expect entry size to be about 256 bytes. But it is strongly
      * recommended always to configure {@linkplain #keySize(int) key size} and {@linkplain #valueSize(int)
      * value size}, if they couldn't be derived statically.
-     *
+     * <p/>
      * <p>If entry size is not configured explicitly by calling this method, it is computed based on
      * {@linkplain #metaDataBytes(int) meta data bytes}, plus {@linkplain #keySize(int) key size}, plus
      * {@linkplain #valueSize(int) value size}, plus a few bytes required by implementations, with respect to
      * {@linkplain #entryAndValueAlignment(Alignment) alignment}.
-     *
+     * <p/>
      * <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, the actual
      * entry size will be 32 (30 aligned to 4 bytes). If you don't want entry size to be aligned, set {@code
@@ -343,15 +343,15 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
     /**
      * 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/>
      * <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/>
      * <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/>
      * <p>Default is {@link Alignment#OF_4_BYTES}.
      *
      * @param alignment the new alignment of the maps constructed by this builder
@@ -436,12 +436,12 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
     /**
      * Configures if the maps created by this builder should return {@code null} instead of previous mapped
      * values on {@link ChronicleMap#put(Object, Object) ChornicleMap.put(key, value)} calls.
-     *
+     * <p/>
      * <p>{@link Map#put(Object, Object) Map.put()} returns the previous value, functionality which is rarely
      * used but fairly cheap for {@link HashMap}. In the case, for an off heap collection, it has to create a
      * new object and deserialize the data from off-heap memory. It's expensive for something you probably
      * don't use.
-     *
+     * <p/>
      * <p>By default, of cause, {@code ChronicleMap} conforms the general {@code Map} contract and returns the
      * previous mapped value on {@code put()} calls.
      *
@@ -463,7 +463,7 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
     /**
      * Configures if the maps created by this builder should return {@code null} instead of the last mapped
      * value on {@link ChronicleMap#remove(Object) ChronicleMap.remove(key)} calls.
-     *
+     * <p/>
      * <p>{@link Map#remove(Object) Map.remove()} returns the previous value, functionality which is rarely
      * used but fairly cheap for {@link HashMap}. In the case, for an off heap collection, it has to create a
      * new object and deserialize the data from off-heap memory. It's expensive for something you probably
@@ -666,10 +666,10 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
      * Specifies the value to be put for each key queried in {@link ChronicleMap#get get()} and {@link
      * ChronicleMap#getUsing(Object, Object) getUsing()} methods, if the key is absent in the map. Then this
      * default value is returned from query method.
-     *
+     * <p/>
      * <p>Setting default value to {@code null} is interpreted as map shouldn't put any default value for
      * absent keys. This is by default.
-     *
+     * <p/>
      * <p>This configuration overrides any previous {@link #defaultValueProvider(DefaultValueProvider)}
      * configuration to this {@code ChronicleMapBuilder}.
      *
@@ -688,7 +688,7 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
      * ChronicleMap#getUsing(Object, Object) getUsing()} calls, if the key is absent in the map. If the
      * obtained value is non-null, it is put for the key in the map and then returned from current {@code
      * get()} or {@code getUsing()} call.
-     *
+     * <p/>
      * <p>This configuration overrides any previous {@link #defaultValue(Object)} configuration to this {@code
      * ChronicleMapBuilder}.
      *
@@ -791,11 +791,11 @@ public class ChronicleMapBuilder<K, V> implements Cloneable,
         return identifier != -1;
     }
 
-      void preMapConstruction() {
+    void preMapConstruction() {
         keyBuilder.objectSerializer(objectSerializer());
         valueBuilder.objectSerializer(objectSerializer());
 
-        int maxSize = entrySize() * figureBufferAllocationFactor();
+        long maxSize = (long) entrySize() * figureBufferAllocationFactor();
         keyBuilder.maxSize(maxSize);
         valueBuilder.maxSize(maxSize);
 

src/test/java/net/openhft/chronicle/map/OSResizesMain.java

@@ -35,7 +35,7 @@ public class OSResizesMain {
         File file = File.createTempFile("over-sized", "deleteme");
         ChronicleMap<String, String> map = ChronicleMapBuilder.of(String.class, String.class)
                 .entrySize(100 * 1024 * 1024)
-                .entries(1000000)
+                .entries(1000000L)
                 .create(file);
         for (int i = 0; i < 10000; i++) {
             char[] chars = new char[i];