--- jsr166/src/extra166y/CustomConcurrentHashMap.java	2009/08/12 04:02:45	1.4
+++ jsr166/src/extra166y/CustomConcurrentHashMap.java	2010/09/01 23:26:57	1.11
@@ -53,10 +53,10 @@ import sun.misc.Unsafe;
  *     (STRONG,
  *      new Equivalence<Person>() {
  *          public boolean equal(Person k, Object x) {
- *            return x instanceOf Person && k.name.equals(((Person)x).name);
+ *            return x instanceof Person && k.name.equals(((Person)x).name);
  *          }
  *          public int hash(Object x) {
- *             return (x instanceOf Person)? ((Person)x).name.hashCode() : 0;
+ *             return (x instanceof Person)? ((Person)x).name.hashCode() : 0;
  *          }
  *        },
  *      STRONG, EQUALS, 0);
@@ -533,9 +533,12 @@ public class CustomConcurrentHashMap<K,
             int sc = (int)((1L + (4L * es) / 3) >>> SEGMENT_BITS);
             if (sc < MIN_SEGMENT_CAPACITY)
                 sc = MIN_SEGMENT_CAPACITY;
-            else if (sc > MAX_SEGMENT_CAPACITY)
-                sc = MAX_SEGMENT_CAPACITY;
-            this.initialSegmentCapacity = sc;
+            int capacity = MIN_SEGMENT_CAPACITY; // ensure power of two
+            while (capacity < sc)
+                capacity <<= 1;
+            if (capacity > MAX_SEGMENT_CAPACITY)
+                capacity = MAX_SEGMENT_CAPACITY;
+            this.initialSegmentCapacity = capacity;
         }
         this.segments = (Segment[])new Segment[NSEGMENTS];
     }
@@ -956,6 +959,10 @@ public class CustomConcurrentHashMap<K,
                     while (p != null) {
                         Node n = p.getLinkage();
                         if (p.get() != null && p.getValue() != null) {
+                            pred = p;
+                            p = n;
+                        }
+                        else {
                             if (pred == null)
                                 tab[i] = n;
                             else
@@ -963,10 +970,6 @@ public class CustomConcurrentHashMap<K,
                             seg.decrementCount();
                             p = n;
                         }
-                        else {
-                            pred = p;
-                            p = n;
-                        }
                     }
                 }
             } finally {
@@ -2098,7 +2101,7 @@ public class CustomConcurrentHashMap<K,
         final int locator;
         final CustomConcurrentHashMap cchm;
         WeakKeyNode(int locator, Object key, CustomConcurrentHashMap cchm) {
-            super(key);
+            super(key, getReclamationQueue());
             this.locator = locator;
             this.cchm = cchm;
         }
@@ -2393,7 +2396,7 @@ public class CustomConcurrentHashMap<K,
         final int locator;
         final CustomConcurrentHashMap cchm;
         SoftKeyNode(int locator, Object key, CustomConcurrentHashMap cchm) {
-            super(key);
+            super(key, getReclamationQueue());
             this.locator = locator;
             this.cchm = cchm;
         }
@@ -2981,7 +2984,7 @@ public class CustomConcurrentHashMap<K,
 
     // Temporary Unsafe mechanics for preliminary release
 
-    static final Unsafe _unsafe;
+    static final Unsafe UNSAFE;
     static final long tableBase;
     static final int tableShift;
     static final long segmentsBase;
@@ -3012,14 +3015,14 @@ public class CustomConcurrentHashMap<K,
 
     static {
         try {
-            _unsafe = getUnsafe();
-            tableBase = _unsafe.arrayBaseOffset(Node[].class);
-            int s = _unsafe.arrayIndexScale(Node[].class);
+            UNSAFE = getUnsafe();
+            tableBase = UNSAFE.arrayBaseOffset(Node[].class);
+            int s = UNSAFE.arrayIndexScale(Node[].class);
             if ((s & (s-1)) != 0)
                 throw new Error("data type scale not a power of two");
             tableShift = 31 - Integer.numberOfLeadingZeros(s);
-            segmentsBase = _unsafe.arrayBaseOffset(Segment[].class);
-            s = _unsafe.arrayIndexScale(Segment[].class);
+            segmentsBase = UNSAFE.arrayBaseOffset(Segment[].class);
+            s = UNSAFE.arrayIndexScale(Segment[].class);
             if ((s & (s-1)) != 0)
                 throw new Error("data type scale not a power of two");
             segmentsShift = 31 - Integer.numberOfLeadingZeros(s);
@@ -3031,12 +3034,14 @@ public class CustomConcurrentHashMap<K,
     // Fenced store into segment table array. Unneeded when we have Fences
     static final  void storeNode(Node[] table,
                                  int i, Node r) {
-        _unsafe.putOrderedObject(table, (i << tableShift) + tableBase, r);
+        long nodeOffset = ((long) i << tableShift) + tableBase;
+        UNSAFE.putOrderedObject(table, nodeOffset, r);
     }
 
     static final  void storeSegment(Segment[] segs,
                                     int i, Segment s) {
-        _unsafe.putOrderedObject(segs, (i << segmentsShift) + segmentsBase, s);
+        long segmentOffset = ((long) i << segmentsShift) + segmentsBase;
+        UNSAFE.putOrderedObject(segs, segmentOffset, s);
     }