feat: add clear

apache · Aug 25, 2023 · ecf8dab · ecf8dab
1 parent 0cd8ec0
commit ecf8dab
Showing 1 changed file with 120 additions and 73 deletions.
diff --git a/hugegraph-core/src/main/java/org/apache/hugegraph/util/collection/IntMapByDynamicHash.java b/hugegraph-core/src/main/java/org/apache/hugegraph/util/collection/IntMapByDynamicHash.java
@@ -1,3 +1,20 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership. The ASF
+ * licenses this file to You 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 org.apache.hugegraph.util.collection;
 
 import java.util.concurrent.atomic.AtomicInteger;
@@ -29,44 +46,38 @@ public class IntMapByDynamicHash implements IntMap {
 
     private volatile Entry[] table;
 
+    /**
+     * Partition counting to improve the concurrency performance of addToSize()
+     */
     private int[] partitionedSize;
 
     private static final Entry RESIZING = new Entry(NULL_VALUE, NULL_VALUE, 1);
     private static final Entry RESIZED = new Entry(NULL_VALUE, NULL_VALUE, 2);
 
     private static final Entry RESIZE_SENTINEL = new Entry(NULL_VALUE, NULL_VALUE, 3);
 
-    private static final Unsafe UNSAFE = IntSet.UNSAFE;
-
-    private static final long ENTRY_ARRAY_BASE;
-
-    private static final int ENTRY_ARRAY_SHIFT;
-
-    private static final long INT_ARRAY_BASE;
-
-    private static final int INT_ARRAY_SHIFT;
-
-    private static final long SIZE_OFFSET;
-
+    /**
+     * must be 2^n - 1
+     */
     private static final int SIZE_BUCKETS = 7;
 
 
     /* ---------------- Table element access -------------- */
-    private static Object arrayAt(Object[] array, int index) {
+    private static Object tableAt(Object[] array, int index) {
         return UNSAFE.getObjectVolatile(array,
                                         ((long) index << ENTRY_ARRAY_SHIFT) +
                                         ENTRY_ARRAY_BASE);
     }
 
-    private static boolean casArrayAt(Object[] array, int index, Object expected, Object newValue) {
+    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);
     }
 
-    private static void setArrayAt(Object[] array, int index, Object newValue) {
+    private static void setTableAt(Object[] array, int index, Object newValue) {
         UNSAFE.putObjectVolatile(array, ((long) index << ENTRY_ARRAY_SHIFT) + ENTRY_ARRAY_BASE,
                                  newValue);
     }
@@ -81,31 +92,6 @@ private static int tableSizeFor(int c) {
         return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
     }
 
-    static {
-        try {
-            Class<?> tableClass = Entry[].class;
-            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);
-
-            Class<?> intArrayClass = int[].class;
-            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);
-        }
-    }
-
     @SuppressWarnings("UnusedDeclaration")
     private volatile int size; // updated via atomic field updater
 
@@ -139,25 +125,25 @@ public IntMapByDynamicHash(int initialCapacity) {
     public boolean put(int key, int value) {
         int hash = this.hash(key);
         Entry[] currentArray = this.table;
-        Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, hash);
+        Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, hash);
         if (o == null) {
             Entry newEntry = new Entry(key, value);
             this.addToSize(1);
-            if (IntMapByDynamicHash.casArrayAt(currentArray, hash, null, newEntry)) {
+            if (IntMapByDynamicHash.casTableAt(currentArray, hash, null, newEntry)) {
                 return true;
             }
             this.addToSize(-1);
         }
 
-        return this.slowPut(key, value, hash, currentArray);
+        return this.slowPut(key, value, currentArray);
     }
 
-    private boolean slowPut(int key, int value, int hash, Entry[] currentArray) {
+    private boolean slowPut(int key, int value, Entry[] currentArray) {
         outer:
         while (true) {
             int length = currentArray.length;
-            int index = hash;
-            Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, index);
+            int index = hash(key, length);
+            Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
                 currentArray = this.helpWithResizeWhileCurrentIndex(currentArray, index);
             } else {
@@ -168,7 +154,7 @@ private boolean slowPut(int key, int value, int hash, Entry[] currentArray) {
                         Entry newEntry = new Entry(e.getKey(),
                                                    value,
                                                    this.createReplacementChainForRemoval(o, e));
-                        if (!IntMapByDynamicHash.casArrayAt(currentArray, index, o,
+                        if (!IntMapByDynamicHash.casTableAt(currentArray, index, o,
                                                             newEntry)) {
                             //noinspection ContinueStatementWithLabel
                             continue outer;
@@ -178,7 +164,7 @@ private boolean slowPut(int key, int value, int hash, Entry[] currentArray) {
                     e = e.getNext();
                 }
                 Entry newEntry = new Entry(key, value, o);
-                if (IntMapByDynamicHash.casArrayAt(currentArray, index, o, newEntry)) {
+                if (IntMapByDynamicHash.casTableAt(currentArray, index, o, newEntry)) {
                     this.incrementSizeAndPossiblyResize(currentArray, length, o);
                     return true;
                 }
@@ -191,7 +177,7 @@ public int get(int key) {
         int hash = this.hash(key);
         Entry[] currentArray = this.table;
         int index = hash;
-        Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, index);
+        Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
         if (o == RESIZED || o == RESIZING) {
             return this.slowGet(key, currentArray);
         }
@@ -209,7 +195,7 @@ private int slowGet(int key, Entry[] currentArray) {
             int length = currentArray.length;
             int hash = this.hash(key, length);
             int index = hash;
-            Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, index);
+            Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
                 currentArray = this.helpWithResizeWhileCurrentIndex(currentArray, index);
             } else {
@@ -248,7 +234,36 @@ public IntIterator values() {
 
     @Override
     public void clear() {
-
+        Entry[] currentArray = this.table;
+        ResizeContainer resizeContainer;
+        do {
+            resizeContainer = null;
+            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;
+                    if (IntMapByDynamicHash.casTableAt(currentArray, i, o, null)) {
+                        int removedEntries = 0;
+                        while (e != null) {
+                            removedEntries++;
+                            e = e.getNext();
+                        }
+                        this.addToSize(-removedEntries);
+                    }
+                }
+            }
+            if (resizeContainer != null) {
+                if (resizeContainer.isNotDone()) {
+                    this.helpWithResize(currentArray);
+                    resizeContainer.waitForAllResizers();
+                }
+                currentArray = resizeContainer.nextArray;
+            }
+        } while (resizeContainer != null);
     }
 
     @Override
@@ -280,7 +295,7 @@ private Entry getEntry(int key) {
         while (true) {
             int length = currentArray.length;
             int index = this.hash(key, length);
-            Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, index);
+            Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
                 currentArray = this.helpWithResizeWhileCurrentIndex(currentArray, index);
             } else {
@@ -363,7 +378,7 @@ private void incrementSizeAndPossiblyResize(Entry[] currentArray, int length, En
     private Entry[] helpWithResizeWhileCurrentIndex(Entry[] currentArray, int index) {
         Entry[] newArray = this.helpWithResize(currentArray);
         int helpCount = 0;
-        while (IntMapByDynamicHash.arrayAt(currentArray, index) != RESIZED) {
+        while (IntMapByDynamicHash.tableAt(currentArray, index) != RESIZED) {
             helpCount++;
             newArray = this.helpWithResize(currentArray);
             if ((helpCount & 7) == 0) {
@@ -382,7 +397,7 @@ private void resize(Entry[] oldTable) {
     private void resize(Entry[] oldTable, int newSize) {
         int oldCapacity = oldTable.length;
         int end = oldCapacity - 1;
-        Entry last = (Entry) IntMapByDynamicHash.arrayAt(oldTable, end);
+        Entry last = (Entry) IntMapByDynamicHash.tableAt(oldTable, end);
         if (this.size() < end && last == RESIZE_SENTINEL) {
             return;
         }
@@ -394,13 +409,13 @@ private void resize(Entry[] oldTable, int newSize) {
         if (last == null || last == RESIZE_SENTINEL) {
             // allocating a new array is too expensive to make this an atomic operation
             synchronized (oldTable) {
-                if (IntMapByDynamicHash.arrayAt(oldTable, end) == null) {
-                    IntMapByDynamicHash.setArrayAt(oldTable, end, RESIZE_SENTINEL);
+                if (IntMapByDynamicHash.tableAt(oldTable, end) == null) {
+                    IntMapByDynamicHash.setTableAt(oldTable, end, RESIZE_SENTINEL);
                     if (this.partitionedSize == null && newSize >= PARTITIONED_SIZE_THRESHOLD) {
                         this.partitionedSize = new int[SIZE_BUCKETS * 16];
                     }
                     resizeContainer = new ResizeContainer(new Entry[newSize], oldTable.length - 1);
-                    IntMapByDynamicHash.setArrayAt(oldTable, end, resizeContainer);
+                    IntMapByDynamicHash.setTableAt(oldTable, end, resizeContainer);
                     ownResize = true;
                 }
             }
@@ -428,9 +443,9 @@ private void transfer(Entry[] src, ResizeContainer resizeContainer) {
         Entry[] dest = resizeContainer.nextArray;
 
         for (int j = 0; j < src.length - 1; ) {
-            Entry o = (Entry) IntMapByDynamicHash.arrayAt(src, j);
+            Entry o = (Entry) IntMapByDynamicHash.tableAt(src, j);
             if (o == null) {
-                if (IntMapByDynamicHash.casArrayAt(src, j, null, RESIZED)) {
+                if (IntMapByDynamicHash.casTableAt(src, j, null, RESIZED)) {
                     j++;
                 }
             } else if (o == RESIZED || o == RESIZING) {
@@ -449,12 +464,12 @@ private void transfer(Entry[] src, ResizeContainer resizeContainer) {
                 }
             } else {
                 Entry e = o;
-                if (IntMapByDynamicHash.casArrayAt(src, j, o, RESIZING)) {
+                if (IntMapByDynamicHash.casTableAt(src, j, o, RESIZING)) {
                     while (e != null) {
                         this.unconditionalCopy(dest, e);
                         e = e.getNext();
                     }
-                    IntMapByDynamicHash.setArrayAt(src, j, RESIZED);
+                    IntMapByDynamicHash.setTableAt(src, j, RESIZED);
                     j++;
                 }
             }
@@ -468,7 +483,7 @@ private void transfer(Entry[] src, ResizeContainer resizeContainer) {
      */
     private Entry[] helpWithResize(Entry[] currentArray) {
         ResizeContainer resizeContainer =
-            (ResizeContainer) IntMapByDynamicHash.arrayAt(currentArray,
+            (ResizeContainer) IntMapByDynamicHash.tableAt(currentArray,
                                                           currentArray.length - 1);
         Entry[] newTable = resizeContainer.nextArray;
         if (resizeContainer.getQueuePosition() > ResizeContainer.QUEUE_INCREMENT) {
@@ -489,22 +504,22 @@ private void reverseTransfer(Entry[] src, ResizeContainer resizeContainer) {
                     start = 0;
                 }
                 for (int j = end - 1; j >= start; ) {
-                    Entry o = (Entry) IntMapByDynamicHash.arrayAt(src, j);
+                    Entry o = (Entry) IntMapByDynamicHash.tableAt(src, j);
                     if (o == null) {
-                        if (IntMapByDynamicHash.casArrayAt(src, j, null, RESIZED)) {
+                        if (IntMapByDynamicHash.casTableAt(src, j, null, RESIZED)) {
                             j--;
                         }
                     } else if (o == RESIZED || o == RESIZING) {
                         resizeContainer.zeroOutQueuePosition();
                         return;
                     } else {
                         Entry e = o;
-                        if (IntMapByDynamicHash.casArrayAt(src, j, o, RESIZING)) {
+                        if (IntMapByDynamicHash.casTableAt(src, j, o, RESIZING)) {
                             while (e != null) {
                                 this.unconditionalCopy(dest, e);
                                 e = e.getNext();
                             }
-                            IntMapByDynamicHash.setArrayAt(src, j, RESIZED);
+                            IntMapByDynamicHash.setTableAt(src, j, RESIZED);
                             j--;
                         }
                     }
@@ -513,15 +528,14 @@ private void reverseTransfer(Entry[] src, ResizeContainer resizeContainer) {
         }
     }
 
-    private void unconditionalCopy(Object[] dest, Entry toCopyEntry) {
-        int hash = this.hash(toCopyEntry.getKey());
-        Object[] currentArray = dest;
+    private void unconditionalCopy(Entry[] dest, Entry toCopyEntry) {
+        Entry[] currentArray = dest;
         while (true) {
             int length = currentArray.length;
-            int index = hash;
-            Entry o = (Entry) IntMapByDynamicHash.arrayAt(currentArray, index);
+            int index = this.hash(toCopyEntry.getKey(), length);
+            Entry o = (Entry) IntMapByDynamicHash.tableAt(currentArray, index);
             if (o == RESIZED || o == RESIZING) {
-                currentArray = ((ResizeContainer) IntMapByDynamicHash.arrayAt(currentArray,
+                currentArray = ((ResizeContainer) IntMapByDynamicHash.tableAt(currentArray,
                                                                               length -
                                                                               1)).nextArray;
             } else {
@@ -536,7 +550,7 @@ private void unconditionalCopy(Object[] dest, Entry toCopyEntry) {
                     newEntry =
                         new Entry(toCopyEntry.getKey(), toCopyEntry.getValue(), (Entry) o);
                 }
-                if (IntMapByDynamicHash.casArrayAt(currentArray, index, o, newEntry)) {
+                if (IntMapByDynamicHash.casTableAt(currentArray, index, o, newEntry)) {
                     return;
                 }
             }
@@ -667,4 +681,37 @@ public String toString() {
             return this.key + "=" + this.value;
         }
     }
+
+    /* ---------------- Unsafe mechanics -------------- */
+    private static final Unsafe UNSAFE = IntSet.UNSAFE;
+    private static final long ENTRY_ARRAY_BASE;
+    private static final int ENTRY_ARRAY_SHIFT;
+    private static final long INT_ARRAY_BASE;
+    private static final int INT_ARRAY_SHIFT;
+    private static final long SIZE_OFFSET;
+
+    static {
+        try {
+            Class<?> tableClass = Entry[].class;
+            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);
+
+            Class<?> intArrayClass = int[].class;
+            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);
+        }
+    }
 }