From 4824bf600d5033f6041d6d98c359d5c22961e2cc Mon Sep 17 00:00:00 2001
From: Mike Duigou <mduigou@openjdk.org>
Date: Wed, 13 Jun 2012 16:48:30 -0700
Subject: [PATCH] 7173919: Minor optimization of hashing methods

Several minor optimizations to hashing methods used by hash map classes

Reviewed-by: dholmes
---
 jdk/src/share/classes/java/util/HashMap.java  |  5 ++---
 .../share/classes/java/util/Hashtable.java    | 20 +++++++++----------
 .../share/classes/java/util/WeakHashMap.java  |  6 ++----
 .../util/concurrent/ConcurrentHashMap.java    |  4 +---
 4 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/jdk/src/share/classes/java/util/HashMap.java b/jdk/src/share/classes/java/util/HashMap.java
index 2191b981344..4687905e428 100644
--- a/jdk/src/share/classes/java/util/HashMap.java
+++ b/jdk/src/share/classes/java/util/HashMap.java
@@ -288,12 +288,11 @@ public class HashMap<K,V>
      * in lower bits.
      */
     final int hash(Object k) {
-        int h = hashSeed;
         if (k instanceof String) {
-            return ((String)k).hash32();
+            return ((String) k).hash32();
         }
 
-        h ^= k.hashCode();
+        int  h = hashSeed ^ k.hashCode();
 
         // This function ensures that hashCodes that differ only by
         // constant multiples at each bit position have a bounded
diff --git a/jdk/src/share/classes/java/util/Hashtable.java b/jdk/src/share/classes/java/util/Hashtable.java
index 593c1710a2a..f82c300838e 100644
--- a/jdk/src/share/classes/java/util/Hashtable.java
+++ b/jdk/src/share/classes/java/util/Hashtable.java
@@ -194,19 +194,17 @@ public class Hashtable<K,V>
     transient final int hashSeed = sun.misc.Hashing.randomHashSeed(this);
 
     private int hash(Object k) {
-        int h = hashSeed;
-
         if (k instanceof String) {
             return ((String)k).hash32();
-        } else {
-            h ^= k.hashCode();
-
-            // This function ensures that hashCodes that differ only by
-            // constant multiples at each bit position have a bounded
-            // number of collisions (approximately 8 at default load factor).
-            h ^= (h >>> 20) ^ (h >>> 12);
-            return h ^ (h >>> 7) ^ (h >>> 4);
         }
+
+        int h = hashSeed ^ k.hashCode();
+
+        // This function ensures that hashCodes that differ only by
+        // constant multiples at each bit position have a bounded
+        // number of collisions (approximately 8 at default load factor).
+        h ^= (h >>> 20) ^ (h >>> 12);
+        return h ^ (h >>> 7) ^ (h >>> 4);
     }
 
     /**
@@ -1015,7 +1013,7 @@ public class Hashtable<K,V>
      */
     private static class Entry<K,V> implements Map.Entry<K,V> {
         final int hash;
-        K key;
+        final K key;
         V value;
         Entry<K,V> next;
 
diff --git a/jdk/src/share/classes/java/util/WeakHashMap.java b/jdk/src/share/classes/java/util/WeakHashMap.java
index ed9e1ad9396..26e22aa10d3 100644
--- a/jdk/src/share/classes/java/util/WeakHashMap.java
+++ b/jdk/src/share/classes/java/util/WeakHashMap.java
@@ -295,13 +295,11 @@ public class WeakHashMap<K,V>
      * otherwise encounter collisions for hashCodes that do not differ
      * in lower bits.
      */
-    int hash(Object k) {
-        int h = hashSeed;
+    final int hash(Object k) {
         if (k instanceof String) {
             return ((String) k).hash32();
-        } else {
-            h ^= k.hashCode();
         }
+        int  h = hashSeed ^ k.hashCode();
 
         // This function ensures that hashCodes that differ only by
         // constant multiples at each bit position have a bounded
diff --git a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
index deddc7f0496..66ae51667d5 100644
--- a/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
+++ b/jdk/src/share/classes/java/util/concurrent/ConcurrentHashMap.java
@@ -269,13 +269,11 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * differ in lower or upper bits.
      */
     private int hash(Object k) {
-       int h = hashSeed;
-
         if (k instanceof String) {
             return ((String) k).hash32();
         }
 
-        h ^= k.hashCode();
+        int h = hashSeed ^ k.hashCode();
 
         // Spread bits to regularize both segment and index locations,
         // using variant of single-word Wang/Jenkins hash.