# HG changeset patch
# Parent ecd33c6ab12fb2e76d48734260ca7bb4e16a7eea
6624565: Reduce HashSet/LinkedHashSet bloat
Reviewed-by: duke

diff -r ecd33c6ab12f src/share/classes/java/util/HashMap.java
--- a/src/share/classes/java/util/HashMap.java	Tue Feb 26 22:39:50 2013 +0000
+++ b/src/share/classes/java/util/HashMap.java	Fri Mar 01 18:56:46 2013 -0800
@@ -404,8 +404,7 @@
         for(; e != null; e = e.next) {
             Object k;
             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
-                V oldValue = e.value;
-                e.value = value;
+                V oldValue = e.setValue(value);
                 e.recordAccess(this);
                 return oldValue;
             }
@@ -424,8 +423,7 @@
         Entry<K,V> e = (Entry<K,V>)table[0];
         for(; e != null; e = e.next) {
             if (e.key == null) {
-                V oldValue = e.value;
-                e.value = value;
+                V oldValue = e.setValue(value);
                 e.recordAccess(this);
                 return oldValue;
             }
@@ -455,7 +453,7 @@
             Object k;
             if (e.hash == hash &&
                 ((k = e.key) == key || (key != null && key.equals(k)))) {
-                e.value = value;
+                e.setValue(value);
                 return;
             }
         }
@@ -564,7 +562,7 @@
      */
     public V remove(Object key) {
         Entry<K,V> e = removeEntryForKey(key);
-        return (e == null ? null : e.value);
+        return (e == null ? null : e.getValue());
     }
 
     /**
@@ -662,7 +660,7 @@
         Entry<?,?>[] tab = table;
         for (int i = 0; i < tab.length ; i++)
             for (Entry<?,?> e = tab[i] ; e != null ; e = e.next)
-                if (value.equals(e.value))
+                if (value.equals(e.getValue()))
                     return true;
         return false;
     }
@@ -674,7 +672,7 @@
         Entry<?,?>[] tab = table;
         for (int i = 0; i < tab.length ; i++)
             for (Entry<?,?> e = tab[i] ; e != null ; e = e.next)
-                if (e.value == null)
+                if (e.getValue() == null)
                     return true;
         return false;
     }
@@ -703,17 +701,15 @@
         return result;
     }
 
-    static class Entry<K,V> implements Map.Entry<K,V> {
+    static abstract class Entry<K,V> implements Map.Entry<K,V> {
         final K key;
-        V value;
         Entry<K,V> next;
         final int hash;
 
         /**
          * Creates new entry.
          */
-        Entry(int h, K k, V v, Entry<K,V> n) {
-            value = v;
+        Entry(int h, K k, Entry<K,V> n) {
             next = n;
             key = k;
             hash = h;
@@ -723,16 +719,6 @@
             return key;
         }
 
-        public final V getValue() {
-            return value;
-        }
-
-        public final V setValue(V newValue) {
-            V oldValue = value;
-            value = newValue;
-            return oldValue;
-        }
-
         public final boolean equals(Object o) {
             if (!(o instanceof Map.Entry))
                 return false;
@@ -749,8 +735,7 @@
         }
 
         public final int hashCode() {
-            return (key==null   ? 0 : key.hashCode()) ^
-                   (value==null ? 0 : value.hashCode());
+            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
         }
 
         public final String toString() {
@@ -774,6 +759,31 @@
     }
 
     /**
+     * A map entry with a value.
+     *
+     * @param <K>
+     * @param <V>
+     */
+    static class ValueEntry<K,V> extends Entry<K,V> {
+        V value;
+
+        ValueEntry(int h, K k, V v, Entry<K,V> n) {
+            super(h,k,n);
+            value = v;
+        }
+
+        public final V getValue() {
+            return value;
+        }
+
+        public final V setValue(V newValue) {
+            V oldValue = value;
+            value = newValue;
+            return oldValue;
+        }
+    }
+
+    /**
      * Adds a new entry with the specified key, value and hash code to
      * the specified bucket.  It is the responsibility of this
      * method to resize the table if appropriate.
@@ -801,10 +811,14 @@
     void createEntry(int hash, K key, V value, int bucketIndex) {
         @SuppressWarnings("unchecked")
             Entry<K,V> e = (Entry<K,V>)table[bucketIndex];
-        table[bucketIndex] = new Entry<>(hash, key, value, e);
+        table[bucketIndex] = newEntry(hash, key, value, e);
         size++;
     }
 
+    Entry<K,V> newEntry(int hash, K key, V value, Entry<K,V> next) {
+        return new ValueEntry<>(hash, key, value, next);
+    }
+
     private abstract class HashIterator<E> implements Iterator<E> {
         Entry<?,?> next;        // next entry to return
         int expectedModCount;   // For fast-fail
@@ -855,7 +869,7 @@
 
     private final class ValueIterator extends HashIterator<V> {
         public V next() {
-            return nextEntry().value;
+            return nextEntry().getValue();
         }
     }
 
diff -r ecd33c6ab12f src/share/classes/java/util/HashSet.java
--- a/src/share/classes/java/util/HashSet.java	Tue Feb 26 22:39:50 2013 +0000
+++ b/src/share/classes/java/util/HashSet.java	Fri Mar 01 18:56:46 2013 -0800
@@ -25,6 +25,8 @@
 
 package java.util;
 
+import java.io.InvalidObjectException;
+
 /**
  * This class implements the <tt>Set</tt> interface, backed by a hash table
  * (actually a <tt>HashMap</tt> instance).  It makes no guarantees as to the
@@ -100,7 +102,7 @@
      * default initial capacity (16) and load factor (0.75).
      */
     public HashSet() {
-        map = new HashMap<>();
+        map = new SetHashMap<>();
     }
 
     /**
@@ -113,7 +115,7 @@
      * @throws NullPointerException if the specified collection is null
      */
     public HashSet(Collection<? extends E> c) {
-        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
+        map = new SetHashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
         addAll(c);
     }
 
@@ -127,7 +129,7 @@
      *             than zero, or if the load factor is nonpositive
      */
     public HashSet(int initialCapacity, float loadFactor) {
-        map = new HashMap<>(initialCapacity, loadFactor);
+        map = new SetHashMap<>(initialCapacity, loadFactor);
     }
 
     /**
@@ -139,7 +141,7 @@
      *             than zero
      */
     public HashSet(int initialCapacity) {
-        map = new HashMap<>(initialCapacity);
+        map = new SetHashMap<>(initialCapacity);
     }
 
     /**
@@ -156,7 +158,7 @@
      *             than zero, or if the load factor is nonpositive
      */
     HashSet(int initialCapacity, float loadFactor, boolean dummy) {
-        map = new LinkedHashMap<>(initialCapacity, loadFactor);
+        map = new SetLinkedHashMap<>(initialCapacity, loadFactor);
     }
 
     /**
@@ -295,20 +297,110 @@
         s.defaultReadObject();
 
         // Read in HashMap capacity and load factor and create backing HashMap
-        int capacity = s.readInt();
+        s.readInt(); // ignored
         float loadFactor = s.readFloat();
+
+        if (loadFactor <= 0 || Float.isNaN(loadFactor))
+            throw new InvalidObjectException("Illegal load factor: " +
+                                               loadFactor);
+
+        // Read number of mappings
+        int mappings = s.readInt();
+        if (mappings < 0)
+            throw new InvalidObjectException("Illegal mappings count: " +
+                                               mappings);
+
+        int initialCapacity = (int) Math.min(
+                // capacity chosen by number of mappings
+                // and desired load (if >= 0.25)
+                mappings * Math.min(1 / loadFactor, 4.0f),
+                // we have limits...
+                HashMap.MAXIMUM_CAPACITY);
+        int capacity = 1;
+        // find smallest power of two which holds all mappings
+        while (capacity < initialCapacity) {
+            capacity <<= 1;
+        }
+
         map = (((HashSet<?>)this) instanceof LinkedHashSet ?
-               new LinkedHashMap<E,Object>(capacity, loadFactor) :
-               new HashMap<E,Object>(capacity, loadFactor));
-
-        // Read in size
-        int size = s.readInt();
+               new SetLinkedHashMap<E,Object>(capacity, loadFactor) :
+               new SetHashMap<E,Object>(capacity, loadFactor));
 
         // Read in all elements in the proper order.
-        for (int i=0; i<size; i++) {
+        for (int i=0; i<mappings; i++) {
             @SuppressWarnings("unchecked")
                 E e = (E) s.readObject();
             map.put(e, PRESENT);
         }
     }
+
+    private static class SetHashMap<K, V> extends HashMap<K, V> {
+
+        SetHashMap() {
+            super();
+        }
+
+        SetHashMap(int capacity) {
+            super(capacity);
+        }
+
+        SetHashMap(int initalCapacity, float loadFactor) {
+            super(initalCapacity, loadFactor);
+        }
+
+        static class HashSetEntry<K, V> extends HashMap.Entry<K, V> {
+
+            HashSetEntry(int h, K k, V v, Entry<K, V> n) {
+                super(h, k, n);
+                assert v == HashSet.PRESENT;
+            }
+
+            public final V getValue() {
+                return (V) PRESENT;
+            }
+
+            public final V setValue(V newValue) {
+                assert newValue == HashSet.PRESENT;
+                return (V) PRESENT;
+            }
+        }
+
+        HashMap.Entry<K,V> newEntry(int h, K k, V v, HashMap.Entry<K,V> next) {
+            return new HashSetEntry(h, k, v, next);
+        }
+    }
+
+    private static class SetLinkedHashMap<K,V> extends LinkedHashMap<K,V> {
+        SetLinkedHashMap() {
+            super();
+        }
+
+        SetLinkedHashMap(int capacity) {
+            super(capacity);
+        }
+
+        SetLinkedHashMap(int initalCapacity, float loadFactor) {
+            super(initalCapacity, loadFactor);
+        }
+
+        static class HashSetEntry<K, V> extends LinkedHashMap.Entry<K, V> {
+
+            HashSetEntry(int h, K k, V v, Entry<K, V> n) {
+                super(h, k, n);
+            }
+
+            public final V getValue() {
+                return (V) PRESENT;
+            }
+
+            public final V setValue(V newValue) {
+                assert newValue == HashSet.PRESENT;
+                return (V) PRESENT;
+            }
+        }
+
+        LinkedHashMap.Entry<K,V> newEntry(int h, K k, V v, HashMap.Entry<K,V> next) {
+            return new HashSetEntry(h, k, v, (LinkedHashMap.Entry<K,V>) next);
+        }
+    }
 }
diff -r ecd33c6ab12f src/share/classes/java/util/LinkedHashMap.java
--- a/src/share/classes/java/util/LinkedHashMap.java	Tue Feb 26 22:39:50 2013 +0000
+++ b/src/share/classes/java/util/LinkedHashMap.java	Fri Mar 01 18:56:46 2013 -0800
@@ -238,7 +238,7 @@
      */
     @Override
     void init() {
-        header = new Entry<>(-1, null, null, null);
+        header = newEntry(-1, null, null, null);
         header.before = header.after = header;
     }
 
@@ -271,11 +271,11 @@
         // Overridden to take advantage of faster iterator
         if (value==null) {
             for (Entry<?,?> e = header.after; e != header; e = e.after)
-                if (e.value==null)
+                if (e.getValue()==null)
                     return true;
         } else {
             for (Entry<?,?> e = header.after; e != header; e = e.after)
-                if (value.equals(e.value))
+                if (value.equals(e.getValue()))
                     return true;
         }
         return false;
@@ -301,7 +301,7 @@
         if (e == null)
             return null;
         e.recordAccess(this);
-        return e.value;
+        return e.getValue();
     }
 
     /**
@@ -316,12 +316,12 @@
     /**
      * LinkedHashMap entry.
      */
-    private static class Entry<K,V> extends HashMap.Entry<K,V> {
+    static abstract class Entry<K,V> extends HashMap.Entry<K,V> {
         // These fields comprise the doubly linked list used for iteration.
         Entry<K,V> before, after;
 
-        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
-            super(hash, key, value, next);
+        Entry(int hash, K key, HashMap.Entry<K,V> next) {
+            super(hash, key, next);
         }
 
         /**
@@ -362,6 +362,32 @@
         }
     }
 
+    /**
+     * A map entry with a value.
+     *
+     * @param <K>
+     * @param <V>
+     */
+    static class ValueEntry<K,V> extends Entry<K,V> {
+        V value;
+
+        ValueEntry(int h, K k, V v, Entry<K,V> n) {
+            super(h,k,n);
+            value = v;
+        }
+
+        public final V getValue() {
+            return value;
+        }
+
+        public final V setValue(V newValue) {
+            V oldValue = value;
+            value = newValue;
+            return oldValue;
+        }
+    }
+
+
     private abstract class LinkedHashIterator<T> implements Iterator<T> {
         Entry<K,V> nextEntry    = header.after;
         Entry<K,V> lastReturned = null;
@@ -405,7 +431,7 @@
     }
 
     private class ValueIterator extends LinkedHashIterator<V> {
-        public V next() { return nextEntry().value; }
+        public V next() { return nextEntry().getValue(); }
     }
 
     private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
@@ -439,12 +465,16 @@
     void createEntry(int hash, K key, V value, int bucketIndex) {
         @SuppressWarnings("unchecked")
             HashMap.Entry<K,V> old = (HashMap.Entry<K,V>)table[bucketIndex];
-        Entry<K,V> e = new Entry<>(hash, key, value, old);
+        Entry<K,V> e = newEntry(hash, key, value, old);
         table[bucketIndex] = e;
         e.addBefore(header);
         size++;
     }
 
+    LinkedHashMap.Entry<K,V> newEntry(int hash, K k, V v, HashMap.Entry<K,V> next) {
+        return new ValueEntry<>(hash, k, v, (LinkedHashMap.Entry<K,V>) next);
+    }
+
     /**
      * Returns <tt>true</tt> if this map should remove its eldest entry.
      * This method is invoked by <tt>put</tt> and <tt>putAll</tt> after