fix: fix some review

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/util/collection/IntMapByDynamicHash.java

@@ -82,10 +82,10 @@
      */
     public IntMapByDynamicHash(int initialCapacity) {
         if (initialCapacity < 0) {
             throw new IllegalArgumentException("Illegal Initial Capacity: " + initialCapacity);
         }
         if (initialCapacity > MAXIMUM_CAPACITY) {
             initialCapacity = MAXIMUM_CAPACITY;
         }
         long size = (long) (1.0 + (long) initialCapacity / LOAD_FACTOR);
         int cap = (size >= (long) MAXIMUM_CAPACITY) ?
@@ -93,7 +93,7 @@
         if (cap >= PARTITIONED_SIZE_THRESHOLD) {
             // we want 7 extra slots, and 64 bytes for each slot int are 4 bytes,
             // so 64 bytes are 16 ints.
             this.partitionedSize =
                 new int[SIZE_BUCKETS * 16];
         }
         // The end index is for resizeContainer
@@ -124,15 +124,17 @@
     }
 
     /* ---------------- Table element access -------------- */
+
+    private static long entryOffset(int index) {
+        return ((long) index << ENTRY_ARRAY_SHIFT) + ENTRY_ARRAY_BASE;
+    }
+
     private static Object tableAt(Object[] array, int index) {
-        return UNSAFE.getObjectVolatile(array,
-                                        ((long) index << ENTRY_ARRAY_SHIFT) + ENTRY_ARRAY_BASE);
+        return UNSAFE.getObjectVolatile(array, entryOffset(index));
     }
 
     private static boolean casTableAt(Object[] array, int index, Object expected, Object newValue) {
-        return UNSAFE.compareAndSwapObject(array,
-                                           ((long) index << ENTRY_ARRAY_SHIFT) + ENTRY_ARRAY_BASE,
-                                           expected, newValue);
+        return UNSAFE.compareAndSwapObject(array, entryOffset(index), expected, newValue);
     }
 
     /**
@@ -205,7 +207,7 @@
                     if (IntMapByDynamicHash.casTableAt(currentTable, index, o, newEntry)) {
                         return oldVal;
                     }
                 } else {
                     // Key not found, add a new entry
                     Entry newEntry = new Entry(key, value, o);
                     if (IntMapByDynamicHash.casTableAt(currentTable, index, o, newEntry)) {
@@ -213,7 +215,7 @@
                         return NULL_VALUE;
                     }
                 }
             }
         }
     }
 
@@ -239,7 +241,7 @@
                 return e.value;
             }
         }
         return NULL_VALUE;
     }
 
     /**
@@ -265,9 +267,9 @@
                     if (candidate == key) {
                         return e.getValue();
                     }
                     e = e.getNext();
                 }
                 return NULL_VALUE;
             }
         }
     }
@@ -280,27 +282,27 @@
      */
     @Override
     public boolean remove(int key) {
         int hash = this.hash(key);
         Entry[] currentTable = this.table;
         Entry o = (Entry) IntMapByDynamicHash.tableAt(currentTable, hash);
         if (o == RESIZED || o == RESIZING) {
             return this.slowRemove(key, currentTable) != null;
         }
 
         Entry e = o;
         while (e != null) {
             int candidate = e.getKey();
             if (candidate == key) {
                 Entry replacement = this.createReplacementChainForRemoval(o, e);
                 if (IntMapByDynamicHash.casTableAt(currentTable, hash, o, replacement)) {
                     this.addToSize(-1);
                     return true;
                 }
                 return this.slowRemove(key, currentTable) != null;
             }
             e = e.getNext();
         }
         return false;
     }
 
     /**
@@ -317,35 +319,35 @@
         Entry o;
 
         while (true) {
             length = currentTable.length;
             index = this.hash(key, length);
             o = (Entry) IntMapByDynamicHash.tableAt(currentTable, index);
             if (o == RESIZED || o == RESIZING) {
                 currentTable = this.helpWithResizeWhileCurrentIndex(currentTable, index);
             } else {
                 Entry e = o;
                 Entry prev = null;
 
                 while (e != null) {
                     int candidate = e.getKey();
                     if (candidate == key) {
                         Entry replacement = this.createReplacementChainForRemoval(o, e);
                         if (IntMapByDynamicHash.casTableAt(currentTable, index, o, replacement)) {
                             this.addToSize(-1);
                             return e;
                         }
                         // Key found, but CAS failed, restart the loop
                         break;
                     }
                     prev = e;
                     e = e.getNext();
                 }
 
                 if (prev != null) {
                     // Key doesn't found
                     return null;
                 }
             }
         }
     }
 
@@ -382,8 +384,8 @@
             for (int i = 0; i < currentArray.length - 1; i++) {
                 Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, i);
                 if (o == RESIZED || o == RESIZING) {
                     resizeContainer =
                         (ResizeContainer) IntMapByDynamicHash.tableAt(currentArray,
                                                                       currentArray.length - 1);
                 } else if (o != null) {
                     Entry e = o;
@@ -399,10 +401,10 @@
             }
             if (resizeContainer != null) {
                 if (resizeContainer.isNotDone()) {
                     this.helpWithResize(currentArray);
                     resizeContainer.waitForAllResizers();
                 }
                 currentArray = resizeContainer.nextArray;
             }
         } while (resizeContainer != null);
     }
@@ -420,7 +422,7 @@
 
     @Override
     public boolean concurrent() {
         return true;
     }
 
     private int hash(int key) {
@@ -438,7 +440,7 @@
             int index = this.hash(key, length);
             Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
                 currentArray = this.helpWithResizeWhileCurrentIndex(currentArray, index);
             } else {
                 Entry e = o;
                 while (e != null) {
@@ -450,7 +452,7 @@
                 }
                 return null;
             }
         }
     }
 
     private void addToSize(int value) {
@@ -475,9 +477,9 @@
                                              localSize + value)) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     private void incrementLocalSize(int value) {
@@ -493,15 +495,15 @@
         if (original == toRemove) {
             return original.getNext();
         }
         Entry replacement = null;
         Entry e = original;
         while (e != null) {
             if (e != toRemove) {
                 replacement = new Entry(e.getKey(), e.getValue(), replacement);
             }
             e = e.getNext();
         }
         return replacement;
     }
 
     private void incrementSizeAndPossiblyResize(Entry[] currentArray, int length, Entry prev) {
@@ -519,10 +521,10 @@
         Entry[] newArray = this.helpWithResize(currentArray);
         int helpCount = 0;
         while (IntMapByDynamicHash.tableAt(currentArray, index) != RESIZED) {
             helpCount++;
             newArray = this.helpWithResize(currentArray);
             if ((helpCount & 7) == 0) {
                 Thread.yield();
             }
         }
         return newArray;
@@ -547,10 +549,10 @@
         int end = oldCapacity - 1;
         Entry last = (Entry) IntMapByDynamicHash.tableAt(oldTable, end);
         if (this.size() < end && last == RESIZE_SENTINEL) {
             return;
         }
         if (oldCapacity >= MAXIMUM_CAPACITY) {
             throw new RuntimeException("max capacity of map exceeded");
         }
         ResizeContainer resizeContainer = null;
         // This ownResize records whether current thread need to perform the expansion operation of
@@ -580,7 +582,7 @@
                 to set the table
                  */
                 if (src != oldTable) {
                     this.helpWithResize(src);
                 }
             }
         } else {
@@ -669,13 +671,13 @@
             int end = start + ResizeContainer.QUEUE_INCREMENT;
             if (end > 0) {
                 if (start < 0) {
                     start = 0;
                 }
                 for (int j = end - 1; j >= start; ) {
                     Entry o = (Entry) IntMapByDynamicHash.tableAt(src, j);
                     if (o == null) {
                         if (IntMapByDynamicHash.casTableAt(src, j, null, RESIZED)) {
                             j--;
                         }
                     } else if (o == RESIZED || o == RESIZING) {
                         resizeContainer.zeroOutQueuePosition();
@@ -694,7 +696,7 @@
                 }
             }
         }
     }
 
     /**
      * Copies an entry from the old table to the new table. This method is called during the resize
@@ -711,9 +713,9 @@
             int index = this.hash(toCopyEntry.getKey(), length);
             Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
                 currentArray =
                     ((ResizeContainer) IntMapByDynamicHash.tableAt(currentArray,
                                                                    length - 1)).nextArray;
             } else {
                 Entry newEntry;
                 if (o == null) {
@@ -723,13 +725,13 @@
                         newEntry = new Entry(toCopyEntry.getKey(), toCopyEntry.getValue());
                     }
                 } else {
                     newEntry = new Entry(toCopyEntry.getKey(), toCopyEntry.getValue(), o);
                 }
                 if (IntMapByDynamicHash.casTableAt(currentArray, index, o, newEntry)) {
                     return;
                 }
             }
         }
     }
 
     /**
@@ -778,7 +780,7 @@
             if (this.resizers.get() > 0) {
                 for (int i = 0; i < 16; i++) {
                     if (this.resizers.get() == 0) {
                         break;
                     }
                 }
                 for (int i = 0; i < 16; i++) {
@@ -789,15 +791,15 @@
                 }
             }
             if (this.resizers.get() > 0) {
                 synchronized (this) {
                     while (this.resizers.get() > 0) {
                         try {
                             this.wait();
                         } catch (InterruptedException e) {
                             // ignore
                         }
                     }
                 }
             }
         }
 
@@ -859,7 +861,7 @@
 
         @Override
         public String toString() {
             return this.key + "=" + this.value;
         }
     }
 
@@ -875,11 +877,11 @@
             this.end = this.currentTable.length - 1;
         }
 
         private IteratorState(Entry[] currentTable, int start, int end) {
             this.currentTable = currentTable;
             this.start = start;
             this.end = end;
         }
     }
 
     /**
@@ -913,30 +915,30 @@
                 Entry o =
                     (Entry) IntMapByDynamicHash.tableAt(this.currentState.currentTable, this.index);
                 if (o == RESIZED || o == RESIZING) {
                     Entry[] nextArray =
                         IntMapByDynamicHash.this.helpWithResizeWhileCurrentIndex(
                             this.currentState.currentTable, this.index);
                     int endResized = this.index + 1;
                     while (endResized < this.currentState.end) {
                         if (IntMapByDynamicHash.tableAt(this.currentState.currentTable,
                                                         endResized) != RESIZED) {
                             break;
                         }
                         endResized++;
                     }
                     if (this.todo == null) {
                         this.todo = new ArrayList<>(4);
                     }
                     if (endResized < this.currentState.end) {
                         this.todo.add(new IteratorState(
                             this.currentState.currentTable, endResized, this.currentState.end));
                     }
                     int powerTwoLength = this.currentState.currentTable.length - 1;
                     this.todo.add(new IteratorState(nextArray, this.index + powerTwoLength,
                                                     endResized + powerTwoLength));
                     this.currentState.currentTable = nextArray;
                     this.currentState.end = endResized;
                     this.currentState.start = this.index;
                 } else if (o != null) {
                     this.next = o;
                     this.index++;
@@ -947,9 +949,9 @@
             }
             if (this.next == null && this.index == this.currentState.end && this.todo != null &&
                 !this.todo.isEmpty()) {
                 this.currentState = this.todo.remove(this.todo.size() - 1);
                 this.index = this.currentState.start;
                 this.findNext();
             }
         }
 
@@ -961,7 +963,7 @@
         final Entry nextEntry() {
             Entry e = this.next;
             if (e == null) {
                 throw new NoSuchElementException();
             }
 
             if ((this.next = e.getNext()) == null) {
@@ -999,7 +1001,7 @@
             ENTRY_ARRAY_BASE = UNSAFE.arrayBaseOffset(tableClass);
             int objectArrayScale = UNSAFE.arrayIndexScale(tableClass);
             if ((objectArrayScale & (objectArrayScale - 1)) != 0) {
                 throw new AssertionError("data type scale not a power of two");
             }
             ENTRY_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(objectArrayScale);
 
@@ -1007,14 +1009,14 @@
             INT_ARRAY_BASE = UNSAFE.arrayBaseOffset(intArrayClass);
             int intArrayScale = UNSAFE.arrayIndexScale(intArrayClass);
             if ((intArrayScale & (intArrayScale - 1)) != 0) {
                 throw new AssertionError("data type scale not a power of two");
             }
             INT_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(intArrayScale);
 
             Class<?> mapClass = IntMapByDynamicHash.class;
             SIZE_OFFSET = UNSAFE.objectFieldOffset(mapClass.getDeclaredField("size"));
         } catch (NoSuchFieldException | SecurityException e) {
             throw new AssertionError(e);
         }
     }
 }

hugegraph-server/hugegraph-test/src/test/java/org/apache/hugegraph/benchmark/map/MapRandomGetPutThroughputTest.java

@@ -54,27 +54,27 @@ public class MapRandomGetPutThroughputTest {
     @Param(value = {"1000", "10000", "100000", "1000000"})
     private int MAP_CAPACITY;
 
-    private ConcurrentHashMap<Integer, Integer> concurrentHashMapNonCap;
+    private ConcurrentHashMap<Integer, Integer> concurrentHashMapWithoutCap;
 
-    private ConcurrentHashMap<Integer, Integer> concurrentHashMap;
+    private ConcurrentHashMap<Integer, Integer> concurrentHashMapWithCap;
 
-    private IntMap intMapBySegments;
+    private IntMap intMapBySegmentsWithCap;
 
-    private IntMap intMapByDynamicHashNonCap;
+    private IntMap intMapByDynamicHashWithoutCap;
 
-    private IntMap intMapByDynamicHash;
+    private IntMap intMapByDynamicHashWithCap;
 
     private static final int THREAD_COUNT = 8;
 
     private static final String OUTPUT_FILE_NAME = "map_random_get_put_result.json";
 
     @Setup(Level.Trial)
     public void prepareMap() {
-        this.concurrentHashMapNonCap = new ConcurrentHashMap<>();
-        this.concurrentHashMap = new ConcurrentHashMap<>(MAP_CAPACITY);
-        this.intMapBySegments = new IntMap.IntMapBySegments(MAP_CAPACITY);
-        this.intMapByDynamicHashNonCap = new IntMapByDynamicHash();
-        this.intMapByDynamicHash = new IntMapByDynamicHash(MAP_CAPACITY);
+        this.concurrentHashMapWithoutCap = new ConcurrentHashMap<>();
+        this.concurrentHashMapWithCap = new ConcurrentHashMap<>(MAP_CAPACITY);
+        this.intMapBySegmentsWithCap = new IntMap.IntMapBySegments(MAP_CAPACITY);
+        this.intMapByDynamicHashWithoutCap = new IntMapByDynamicHash();
+        this.intMapByDynamicHashWithCap = new IntMapByDynamicHash(MAP_CAPACITY);
     }
 
     /**
@@ -94,50 +94,50 @@ int next() {
     @Threads(THREAD_COUNT)
     public void randomGetPutOfConcurrentHashMapWithNoneInitCap(ThreadState state) {
         int key = state.next();
-        if (!this.concurrentHashMapNonCap.containsKey(key)) {
-            this.concurrentHashMapNonCap.put(key, state.next());
+        if (!this.concurrentHashMapWithoutCap.containsKey(key)) {
+            this.concurrentHashMapWithoutCap.put(key, state.next());
         }
-        this.concurrentHashMapNonCap.get(key);
+        this.concurrentHashMapWithoutCap.get(key);
     }
 
     @Benchmark
     @Threads(THREAD_COUNT)
     public void randomGetPutOfConcurrentHashMapWithInitCap(ThreadState state) {
         int key = state.next() & (MAP_CAPACITY - 1);
-        if (!this.concurrentHashMap.containsKey(key)) {
-            this.concurrentHashMap.put(key, state.next());
+        if (!this.concurrentHashMapWithCap.containsKey(key)) {
+            this.concurrentHashMapWithCap.put(key, state.next());
         }
-        this.concurrentHashMap.get(key);
+        this.concurrentHashMapWithCap.get(key);
     }
 
     @Benchmark
     @Threads(THREAD_COUNT)
     public void randomGetPutOfIntMapBySegmentsWithInitCap(ThreadState state) {
         int key = state.next() & (MAP_CAPACITY - 1);
-        if (!this.intMapBySegments.containsKey(key)) {
-            this.intMapBySegments.put(key, state.next());
+        if (!this.intMapBySegmentsWithCap.containsKey(key)) {
+            this.intMapBySegmentsWithCap.put(key, state.next());
         }
-        this.intMapBySegments.get(key);
+        this.intMapBySegmentsWithCap.get(key);
     }
 
     @Benchmark
     @Threads(THREAD_COUNT)
     public void randomGetPutOfIntMapByDynamicHashWithNoneCap(ThreadState state) {
         int key = state.next();
-        if (!this.intMapByDynamicHashNonCap.containsKey(key)) {
-            this.intMapByDynamicHashNonCap.put(key, state.next());
+        if (!this.intMapByDynamicHashWithoutCap.containsKey(key)) {
+            this.intMapByDynamicHashWithoutCap.put(key, state.next());
         }
-        this.intMapByDynamicHashNonCap.get(key);
+        this.intMapByDynamicHashWithoutCap.get(key);
     }
 
     @Benchmark
     @Threads(THREAD_COUNT)
     public void randomGetPutOfIntMapByDynamicHashWithInitCap(ThreadState state) {
         int key = state.next() & (MAP_CAPACITY - 1);
-        if (!this.intMapByDynamicHash.containsKey(key)) {
-            this.intMapByDynamicHash.put(key, state.next());
+        if (!this.intMapByDynamicHashWithCap.containsKey(key)) {
+            this.intMapByDynamicHashWithCap.put(key, state.next());
         }
-        this.intMapByDynamicHash.get(key);
+        this.intMapByDynamicHashWithCap.get(key);
     }
 
     public static void main(String[] args) throws RunnerException {