Added size maps to flat hash tables.

Added parallel mutable hash sets.
Implemented parallel mutable hash set iterators.
Implemented parallel mutable hash set combiners.
Factored out unrolled linked lists into a separate class UnrolledBuffer, added tests.
Added parallel mutable hash set tests, and debugged hashsets.

No review.

4 files changed, 111 insertions, 7 deletions

diff --git a/test/files/scalacheck/parallel-collections/PairOperators.scala b/test/files/scalacheck/parallel-collections/PairOperators.scala
index 48cbd136e5..2055c29d38 100644
--- a/test/files/scalacheck/parallel-collections/PairOperators.scala
+++ b/test/files/scalacheck/parallel-collections/PairOperators.scala
@@ -49,7 +49,7 @@ trait PairOperators[K, V] extends Operators[(K, V)] {
     def apply(kv: (K, V)) = kfm(kv._1).toIterable zip vfm(kv._2).toIterable
   }
 
-  def filterPredicates = zipPredicates(koperators.filterPredicates, voperators.existsPredicates)
+  def filterPredicates = zipPredicates(koperators.filterPredicates, voperators.filterPredicates)
 
   def filterNotPredicates = filterPredicates
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelHashSetCheck.scala b/test/files/scalacheck/parallel-collections/ParallelHashSetCheck.scala
new file mode 100644
index 0000000000..973a5cdf4b
--- /dev/null
+++ b/test/files/scalacheck/parallel-collections/ParallelHashSetCheck.scala
@@ -0,0 +1,94 @@
+package scala.collection.parallel
+package mutable
+
+
+
+import org.scalacheck._
+import org.scalacheck.Gen
+import org.scalacheck.Gen._
+import org.scalacheck.Prop._
+import org.scalacheck.Properties
+import org.scalacheck.Arbitrary._
+
+import scala.collection._
+import scala.collection.parallel.ops._
+
+
+abstract class ParallelHashSetCheck[T](tp: String) extends ParallelSetCheck[T]("mutable.ParHashSet[" + tp + "]") {
+  ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
+  ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
+
+  type CollType = ParHashSet[T]
+
+  def isCheckingViews = false
+
+  def hasStrictOrder = false
+
+  def ofSize(vals: Seq[Gen[T]], sz: Int) = {
+    val hm = new mutable.HashSet[T]
+    val gen = vals(rnd.nextInt(vals.size))
+    for (i <- 0 until sz) hm += sample(gen)
+    hm
+  }
+
+  def fromTraversable(t: Traversable[T]) = {
+    val phm = new ParHashSet[T]
+    var i = 0
+    for (kv <- t.toList) {
+      phm += kv
+      i += 1
+    }
+    phm
+  }
+
+}
+
+
+object IntParallelHashSetCheck extends ParallelHashSetCheck[Int]("Int")
+with IntOperators
+with IntValues
+{
+  override def printDataStructureDebugInfo(ds: AnyRef) = ds match {
+    case pm: ParHashSet[t] =>
+      println("Mutable parallel hash set")
+    case _ =>
+      println("could not match data structure type: " + ds.getClass)
+  }
+
+  override def checkDataStructureInvariants(orig: Traversable[Int], ds: AnyRef) = ds match {
+    case pm: ParHashSet[t] =>
+      // for an example of how not to write code proceed below
+      val invs = pm.brokenInvariants
+
+      val containsall = (for (elem <- orig) yield {
+        if (pm.asInstanceOf[ParHashSet[Int]](elem) == true) true
+        else {
+          println("Does not contain original element: " + elem)
+          println(pm.hashTableContents.table.find(_ == elem))
+          println(pm.hashTableContents.table.indexOf(elem))
+          false
+        }
+      }).foldLeft(true)(_ && _)
+
+
+      if (invs.isEmpty) {
+        if (!containsall) println(pm.debugInformation)
+        containsall
+      } else {
+        println("Invariants broken:\n" + invs.mkString("\n"))
+        false
+      }
+    case _ => true
+  }
+
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
index 0acdb2b0a7..d2d6119997 100644
--- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
@@ -146,7 +146,10 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
         println("mapped to: ")
         println(ms)
         println(mp)
-        println("valid: " + !checkDataStructureInvariants(ms, mp))
+        println("sizes: ")
+        println(ms.size)
+        println(mp.size)
+        println("valid: " + checkDataStructureInvariants(ms, mp))
       }
       ("op index: " + ind) |: (areEqual(ms, mp) && checkDataStructureInvariants(ms, mp))
     }
diff --git a/test/files/scalacheck/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala
index 24e7d09918..4e2d5611f0 100644
--- a/test/files/scalacheck/parallel-collections/pc.scala
+++ b/test/files/scalacheck/parallel-collections/pc.scala
@@ -11,20 +11,25 @@ class ParCollProperties extends Properties("Parallel collections") {
   /*   Collections   */
 
   // parallel arrays
-  //include(mutable.IntParallelArrayCheck)
+  // include(mutable.IntParallelArrayCheck)
 
   // parallel ranges
-  //include(immutable.ParallelRangeCheck)
+  // include(immutable.ParallelRangeCheck)
 
   // parallel immutable hash maps (tries)
-  //include(immutable.IntIntParallelHashMapCheck)
+  // include(immutable.IntIntParallelHashMapCheck)
 
   // parallel immutable hash sets (tries)
-  //include(immutable.IntParallelHashSetCheck)
+  // include(immutable.IntParallelHashSetCheck)
 
   // parallel mutable hash maps (tables)
   // include(mutable.IntIntParallelHashMapCheck)
 
+  // parallel mutable hash sets (tables)
+  include(mutable.IntParallelHashSetCheck)
+
+  // parallel vectors
+
   /*   Views   */
 
   // parallel array views
@@ -32,6 +37,8 @@ class ParCollProperties extends Properties("Parallel collections") {
   // parallel immutable hash map views
 
   // parallel mutable hash map views
+
+  // parallel vector views
 }
 
 
@@ -45,7 +52,7 @@ object Test {
         workers = 1,
         minSize = 0,
         maxSize = 4000,
-        minSuccessfulTests = 100
+        minSuccessfulTests = 250
       ),
       pc
     )