Changeset 12969

Timestamp:

10/09/10 23:28:31 (12 years ago)

Author:

ehuelsmann

Message:

Implement nearly lock-free hash reader functionality, by
looking really well at ConcurrentHashMap? - agreed.

File:

• trunk/abcl/src/org/armedbear/lisp/HashTable.java (modified) (10 diffs)

trunk/abcl/src/org/armedbear/lisp/HashTable.java

@@ -34 +34 @@
 package org.armedbear.lisp;
 
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.locks.ReentrantLock;
 import static org.armedbear.lisp.Lisp.*;
 
@@ -47 +46 @@
     protected int threshold;
     // Array containing the actual key-value mappings.
-    
     @SuppressWarnings("VolatileArrayField")
     protected volatile HashEntry[] buckets;
-    
     // The number of key-value pairs.
-    protected int count;
-    private int mask;
+    protected volatile int count;
     final Comparator comparator;
-    final private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+    final private ReentrantLock lock = new ReentrantLock();
 
     protected HashTable(Comparator c, int size, LispObject rehashSize,
@@ -64 +60 @@
         threshold = (int) (size * loadFactor);
         comparator = c;
-        mask = buckets.length - 1;
     }
 
@@ -157 +152 @@
 
     public void clear() {
-        lock.writeLock().lock();
+        lock.lock();
         try {
             buckets = new HashEntry[buckets.length];
             count = 0;
         } finally {
-            lock.writeLock().unlock();
+            lock.unlock();
         }
     }
@@ -234 +229 @@
 
     protected HashEntry getEntry(LispObject key) {
-        int index = comparator.hash(key) & mask;
-        HashEntry e = buckets[index];
+        HashEntry[] b = buckets;
+        HashEntry e = b[comparator.hash(key) & (b.length - 1)];
         while (e != null) {
             if (comparator.keysEqual(key, e.key)) {
@@ -246 +241 @@
 
     public LispObject get(LispObject key) {
-        lock.readLock().lock();
+        HashEntry e = getEntry(key);
+        LispObject v = (e == null) ? null : e.value;
+
+        if (e == null || v != null) {
+            return v;
+        }
+
+        lock.lock();
+        try {
+            return e.value;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public void put(LispObject key, LispObject value) {
+        lock.lock();
         try {
             HashEntry e = getEntry(key);
-            return (e == null) ? null : e.value;
-        } finally {
-            lock.readLock().unlock();
-        }
-    }
-
-    public void put(LispObject key, LispObject value) {
-        lock.writeLock().lock();
-        try {
-            HashEntry e = getEntry(key);
-            if (e == null) {
+            if (e != null) {
                 e.value = value;
             } else {
@@ -267 +268 @@
                 }
 
-                int index = comparator.hash(key) & mask;
+                int index = comparator.hash(key) & (buckets.length - 1);
                 buckets[index] = new HashEntry(key, value, buckets[index]);
             }
         } finally {
-            lock.writeLock().unlock();
+            lock.unlock();
         }
     }
 
     public LispObject remove(LispObject key) {
-        lock.writeLock().lock();
+        lock.lock();
         try {
-            int index = comparator.hash(key) & mask;
+            int index = comparator.hash(key) & (buckets.length - 1);
 
             HashEntry e = buckets[index];
@@ -297 +298 @@
             return null;
         } finally {
-            lock.writeLock().unlock();
+            lock.unlock();
         }
     }
 
     protected void rehash() {
-        lock.writeLock().lock();
+        lock.lock();
         try {
             final int newCapacity = buckets.length * 2;
             threshold = (int) (newCapacity * loadFactor);
-            mask = newCapacity - 1;
+            int mask = newCapacity - 1;
             HashEntry[] newBuckets = new HashEntry[newCapacity];
 
@@ -319 +320 @@
             buckets = newBuckets;
         } finally {
-            lock.writeLock().unlock();
+            lock.unlock();
         }
     }
@@ -416 +417 @@
 
         LispObject key;
-        LispObject value;
+        volatile LispObject value;
         HashEntry next;