MP-11740 Introduce Long2ShortMap

Author: sarveswaran-m

src/main/java/com/trivago/fastutilconcurrentwrapper/ConcurrentLongShortMapBuilder.java

@@ -0,0 +1,75 @@
+package com.trivago.fastutilconcurrentwrapper;
+
+import com.trivago.fastutilconcurrentwrapper.map.ConcurrentBusyWaitingLongShortMap;
+import com.trivago.fastutilconcurrentwrapper.map.ConcurrentLongShortMap;
+
+public final class ConcurrentLongShortMapBuilder {
+    private MapMode mapMode = MapMode.BLOCKING;
+    private int buckets = 8;
+    private int initialCapacity = 100_000;
+    private float loadFactor = 0.8f;
+    private short defaultValue = LongShortMap.DEFAULT_VALUE;
+
+    private ConcurrentLongShortMapBuilder() {
+
+    }
+
+    public static ConcurrentLongShortMapBuilder newBuilder() {
+        return new ConcurrentLongShortMapBuilder();
+    }
+
+    public ConcurrentLongShortMapBuilder withBuckets(int buckets) {
+        this.buckets = buckets;
+        return this;
+    }
+
+    public ConcurrentLongShortMapBuilder withInitialCapacity(int initialCapacity) {
+        this.initialCapacity = initialCapacity;
+        return this;
+    }
+
+    public ConcurrentLongShortMapBuilder withLoadFactor(float loadFactor) {
+        this.loadFactor = loadFactor;
+        return this;
+    }
+
+    public ConcurrentLongShortMapBuilder withMode(MapMode mapMode) {
+        this.mapMode = mapMode;
+        return this;
+    }
+
+    public ConcurrentLongShortMapBuilder withDefaultValue(short defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+
+    public LongShortMap build() {
+        return mapMode.createMap(this);
+    }
+
+    public enum MapMode {
+        BUSY_WAITING {
+            @Override
+            LongShortMap createMap(ConcurrentLongShortMapBuilder builder) {
+                return new ConcurrentBusyWaitingLongShortMap(
+                        builder.buckets,
+                        builder.initialCapacity,
+                        builder.loadFactor,
+                        builder.defaultValue);
+            }
+        },
+        BLOCKING {
+            @Override
+            LongShortMap createMap(ConcurrentLongShortMapBuilder builder) {
+                return new ConcurrentLongShortMap(
+                        builder.buckets,
+                        builder.initialCapacity,
+                        builder.loadFactor,
+                        builder.defaultValue);
+            }
+        };
+
+        abstract LongShortMap createMap(ConcurrentLongShortMapBuilder builder);
+    }
+}
+

src/main/java/com/trivago/fastutilconcurrentwrapper/LongShortMap.java

@@ -0,0 +1,29 @@
+package com.trivago.fastutilconcurrentwrapper;
+
+import it.unimi.dsi.fastutil.longs.Long2ShortFunction;
+
+import java.util.function.BiFunction;
+
+public interface LongShortMap extends PrimitiveLongKeyMap {
+
+    short DEFAULT_VALUE = 0;
+
+    /**
+     * @param key key to get
+     * @return configured LongShortMap.getDefaultValue(), if the key is not present
+     */
+    short get(long key);
+
+    short put(long key, short value);
+
+    short getDefaultValue();
+
+    short remove(long key);
+
+    boolean remove(long key, short value);
+
+    short computeIfAbsent(long key, Long2ShortFunction mappingFunction);
+
+    short computeIfPresent(long key, BiFunction<Long, Short, Short> mappingFunction);
+}
+

src/main/java/com/trivago/fastutilconcurrentwrapper/map/ConcurrentBusyWaitingLongShortMap.java

@@ -0,0 +1,163 @@
+package com.trivago.fastutilconcurrentwrapper.map;
+
+import com.trivago.fastutilconcurrentwrapper.LongShortMap;
+import com.trivago.fastutilconcurrentwrapper.wrapper.PrimitiveFastutilLongShortWrapper;
+import it.unimi.dsi.fastutil.longs.Long2ShortFunction;
+
+import java.util.concurrent.locks.Lock;
+import java.util.function.BiFunction;
+
+public class ConcurrentBusyWaitingLongShortMap extends PrimitiveConcurrentMap implements LongShortMap {
+
+    private final LongShortMap[] maps;
+    private final short defaultValue;
+
+    public ConcurrentBusyWaitingLongShortMap(int numBuckets,
+                                             int initialCapacity,
+                                             float loadFactor,
+                                             short defaultValue) {
+        super(numBuckets);
+
+        this.maps = new LongShortMap[numBuckets];
+        this.defaultValue = defaultValue;
+
+        for (int i = 0; i < numBuckets; i++) {
+            maps[i] = new PrimitiveFastutilLongShortWrapper(initialCapacity, loadFactor, defaultValue);
+        }
+    }
+
+    @Override
+    public int size() {
+        return super.size(maps);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return super.isEmpty(maps);
+    }
+
+    @Override
+    public boolean containsKey(long key) {
+        int bucket = getBucket(key);
+
+        Lock readLock = locks[bucket].readLock();
+
+        while (true) {
+            if (readLock.tryLock()) {
+                try {
+                    return maps[bucket].containsKey(key);
+                } finally {
+                    readLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public short get(long key) {
+        int bucket = getBucket(key);
+
+        Lock readLock = locks[bucket].readLock();
+
+        while (true) {
+            if (readLock.tryLock()) {
+                try {
+                    return maps[bucket].get(key);
+                } finally {
+                    readLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public short put(long key, short value) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].put(key, value);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public short getDefaultValue() {
+        return defaultValue;
+    }
+
+    @Override
+    public short remove(long key) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].remove(key);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean remove(long key, short value) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].remove(key, value);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public short computeIfAbsent(long key, Long2ShortFunction mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfAbsent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public short computeIfPresent(long key, BiFunction<Long, Short, Short> mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfPresent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+}
+