Tuning of HashMap operations

 - Increase load factor to 0.5 -- the miss rate seems to be still OK
(around one miss per hit or better) while re-sizing costs and go down.

 - Don't lose lowest hashCode bit.

Author: odersky

compiler/src/dotty/tools/dotc/util/GenericHashMap.scala

@@ -56,7 +56,7 @@ abstract class GenericHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
   /** Equality, to be implemented in subclass */
   protected def isEqual(x: Key, y: Key): Boolean
 
-  /** Turn hashcode `x` into a table index */
+  /** Turn successor index or hash code `x` into a table index */
   private def index(x: Int): Int = x & (table.length - 2)
 
   private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))

compiler/src/dotty/tools/dotc/util/HashMap.scala

@@ -4,21 +4,27 @@ package dotty.tools.dotc.util
  *  as comparison
  */
 class HashMap[Key <: AnyRef, Value >: Null <: AnyRef]
-    (initialCapacity: Int = 8, capacityMultiple: Int = 3)
+    (initialCapacity: Int = 8, capacityMultiple: Int = 2)
 extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   import GenericHashMap.DenseLimit
 
-  final def hash(x: Key): Int = x.hashCode
+  /** Hashcode is left-shifted by 1, so lowest bit is not lost
+   *  when taking the index.
+   */
+  final def hash(x: Key): Int = x.hashCode << 1
+
   final def isEqual(x: Key, y: Key): Boolean = x.equals(y)
 
   // The following methods are duplicated from GenericHashMap
   // to avoid polymorphic dispatches
 
-  /** Turn hashcode `x` into a table index */
+  /** Turn successor index or hash code `x` into a table index */
   private def index(x: Int): Int = x & (table.length - 2)
 
   private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) = index(idx + 2)
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
 
   private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
   private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]

compiler/src/dotty/tools/dotc/util/IdentityHashMap.scala

@@ -4,12 +4,14 @@ package dotty.tools.dotc.util
  *  as comparison
  */
 class IdentityHashMap[Key <: AnyRef, Value >: Null <: AnyRef]
-    (initialCapacity: Int = 8, capacityMultiple: Int = 3)
+    (initialCapacity: Int = 8, capacityMultiple: Int = 2)
 extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   import GenericHashMap.DenseLimit
 
-  /** Hashcode, by default `System.identityHashCode`, but can be overriden */
-  final def hash(x: Key): Int = System.identityHashCode(x)
+  /** Hashcode is identityHashCode left-shifted by 1, so lowest bit is not lost
+   *  when taking the index.
+   */
+  final def hash(x: Key): Int = System.identityHashCode(x) << 1
 
   /** Equality, by default `eq`,  but can be overridden */
   final def isEqual(x: Key, y: Key): Boolean = x eq y
@@ -19,11 +21,13 @@ extends GenericHashMap[Key, Value](initialCapacity, capacityMultiple):
   // Aside: It would be nice to have a @specialized annotation that does
   // this automatically
 
-  /** Turn hashcode `x` into a table index */
+  /** Turn successor index or hash code `x` into a table index */
   private def index(x: Int): Int = x & (table.length - 2)
 
   private def firstIndex(key: Key) = if isDense then 0 else index(hash(key))
-  private def nextIndex(idx: Int) = index(idx + 2)
+  private def nextIndex(idx: Int) =
+    Stats.record(statsItem("miss"))
+    index(idx + 2)
 
   private def keyAt(idx: Int): Key = table(idx).asInstanceOf[Key]
   private def valueAt(idx: Int): Value = table(idx + 1).asInstanceOf[Value]