Implemented a (slower) workaround for parallel ...

Implemented a (slower) workaround for parallel vectors. Implemented
group by.

No review.

12 files changed, 250 insertions, 31 deletions

diff --git a/test/benchmarks/source.list b/test/benchmarks/source.list
index 65ab4b9ca9..c5d5f7f8fe 100644
--- a/test/benchmarks/source.list
+++ b/test/benchmarks/source.list
@@ -22,6 +22,7 @@ src/scala/collection/parallel/benchmarks/parallel_array/SumLight.scala
 src/scala/collection/parallel/benchmarks/parallel_array/MinLight.scala
 src/scala/collection/parallel/benchmarks/parallel_array/CountList.scala
 src/scala/collection/parallel/benchmarks/parallel_array/PatchHalf.scala
+src/scala/collection/parallel/benchmarks/parallel_array/GroupBy.scala
 src/scala/collection/parallel/benchmarks/parallel_array/DiffHalf.scala
 src/scala/collection/parallel/benchmarks/parallel_array/TakeMany.scala
 src/scala/collection/parallel/benchmarks/parallel_array/PartialMapLight.scala
@@ -65,6 +66,7 @@ src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala
 src/scala/collection/parallel/benchmarks/generic/Dummy.scala
 src/scala/collection/parallel/benchmarks/parallel_range/RangeBenches.scala
 src/scala/collection/parallel/benchmarks/misc/Dictionary.scala
+src/scala/collection/parallel/benchmarks/misc/Loader.scala
 src/scala/collection/parallel/benchmarks/misc/Coder.scala
 src/scala/collection/parallel/benchmarks/Bench.scala
 src/scala/collection/parallel/benchmarks/hashtries/Foreach.scala
diff --git a/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala b/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala
index 65b9be4ca3..cbda3551e0 100644
--- a/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala
+++ b/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala
@@ -66,6 +66,7 @@ trait BenchmarkRegister {
   register(parallel_array.AggregateLight)
   register(parallel_array.ScanLight)
   register(parallel_array.ScanMedium)
+  register(parallel_array.GroupByLight)
   register(parallel_array.MatrixMultiplication)
 
   // parallel views
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Coder.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Coder.scala
index 4f809cf734..5ed0ca317d 100644
--- a/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Coder.scala
+++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Coder.scala
@@ -2,8 +2,12 @@ package scala.collection.parallel.benchmarks
 package misc
 
 
-import collection.immutable._
-import collection.parallel.immutable._
+
+
+
+
+import collection._ //immutable._
+import collection.parallel._//immutable._
 
 
 class SeqCoder(words: List[String]) {
@@ -23,24 +27,32 @@ class SeqCoder(words: List[String]) {
   /** A map from digit strings to the words that represent
    *  them e.g. `5282` -> List(`Java`, `Kata`, `Lava`, ...)
    */
-  val wordsForNum: Map[String, List[String]] =
-    words groupBy wordCode withDefaultValue List()
+  val wordsForNum: Map[String, Seq[String]] =
+    (words groupBy wordCode).map(t => (t._1, t._2.toSeq)) withDefaultValue Seq()
 
   /** All ways to encode a number as a list of words */
-  def encode(number: String): Set[List[String]] =
-    if (number.isEmpty) Set(List())
+  def encode(number: String): Set[Seq[String]] =
+    if (number.isEmpty) Set(Seq())
     else {
       val splits = (1 to number.length).toSet
-      for {
-	split <- splits
-	word <- wordsForNum(number take split)
-	rest <- encode(number drop split)
-      } yield word :: rest
+      // for {
+      //   split <- splits
+      //   word <- wordsForNum(number take split)
+      //   rest <- encode(number drop split)
+      // } yield word :: rest
+      val r = splits.flatMap(split => {
+        val wfn = wordsForNum(number take split).flatMap(word => {
+          val subs = encode(number drop split)
+          subs.map(rest => word +: rest)
+        })
+        wfn
+      })
+      r
     }
 
   /** Maps a number to a list of all word phrases that can
    *  represent it */
-  def translate(number: String): Set[String] = encode(number) map (_ mkString " ")
+  def translate(number: String) = encode(number)// map (_ mkString " ")
 
   def ??? : Nothing = throw new UnsupportedOperationException
 }
@@ -62,37 +74,43 @@ class ParCoder(words: List[String]) {
   /** A map from digit strings to the words that represent
    *  them e.g. `5282` -> List(`Java`, `Kata`, `Lava`, ...)
    */
-  val wordsForNum: Map[String, List[String]] =
-    words groupBy wordCode withDefaultValue List()
+  val wordsForNum: Map[String, Seq[String]] =
+    (words groupBy wordCode).map(t => (t._1, t._2)) withDefaultValue Seq()
 
   /** All ways to encode a number as a list of words */
-  def encode(number: String): ParSet[List[String]] =
-    if (number.isEmpty) ParSet(List())
+  def encode(number: String): Set[Seq[String]] = if (number.length > 12) {
+    if (number.isEmpty) ParSet(ParSeq())
     else {
       val splits = (1 to number.length).toParSet
       for {
-	split <- splits
-	word <- wordsForNum(number take split)
-	rest <- encode(number drop split)
-      } yield word :: rest
+        split <- splits
+        word <- wordsForNum(number take split)
+        rest <- encode(number drop split)
+      } yield word +: rest
+    }
+  } else {
+    if (number.isEmpty) Set(Seq())
+    else {
+      val splits = (1 to number.length).toSet
+      for {
+        split <- splits
+        word <- wordsForNum(number take split)
+        rest <- encode(number drop split)
+      } yield word +: rest
     }
+  }
 
   /** Maps a number to a list of all word phrases that can
    *  represent it */
-  def translate(number: String): ParSet[String] = encode(number) map (_ mkString " ")
+  def translate(number: String) = {
+    encode(number)// map (_ mkString " ")
+  }
 
   def ??? : Nothing = throw new UnsupportedOperationException
 }
 
 
-/** Test code */
-object Main {
-  def main(args : Array[String]) : Unit = {
-    val coder = new SeqCoder(List("Scala", "Python", "Ruby", "Java", "Kata", "Lava", "a", "rocks", "pack", "rack", "sucks", "works"))
-    println(coder.wordsForNum)
-    println(coder.translate("7225276257"))
-  }
-}
+
 
 
 object Coder extends BenchCompanion {
@@ -110,7 +128,7 @@ class Coder(val size: Int, val parallelism: Int, val runWhat: String) extends Be
 
   override def repetitionsPerRun = 1
 
-  val code = "2328437472947362626"//33"//837976"//"6477323986225453446"
+  val code = "23284374729473626268379762538"
 
   reset
 
@@ -131,6 +149,7 @@ class Coder(val size: Int, val parallelism: Int, val runWhat: String) extends Be
       println("Translation check: " + t.size)
       //println(t)
     case "par" =>
+      collection.parallel.tasksupport.environment.asInstanceOf[concurrent.forkjoin.ForkJoinPool].setParallelism(parallelism)
       parcoder = new ParCoder(Dictionary.wordlist)
       val t = parcoder.translate(code)
       println("Translation check: " + t.size)
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Dictionary.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Dictionary.scala
index 7ab5d94e93..e6ff55d234 100644
--- a/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Dictionary.scala
+++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Dictionary.scala
@@ -4,7 +4,8 @@ package scala.collection.parallel.benchmarks.misc
 
 
 object Dictionary {
-  val words = wordlines.split(System.getProperty("line.separator")).filter(_.trim != "").toList
+  val wordlist = wordlines.split(System.getProperty("line.separator")).filter(_.trim != "").toList
+  val wordarray = wordlist.toArray
   def wordlines = {
     val is = getClass.getClassLoader.getResourceAsStream("scala/collection/parallel/benchmarks/misc/dict.txt")
     scala.io.Source.fromInputStream(is).mkString
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Loader.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Loader.scala
new file mode 100644
index 0000000000..2a9fc2c3ef
--- /dev/null
+++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/misc/Loader.scala
@@ -0,0 +1,64 @@
+package scala.collection.parallel.benchmarks
+package misc
+
+
+
+
+
+
+import collection._ //immutable._
+import collection.parallel._//immutable._
+
+
+
+
+
+
+
+object Loader extends BenchCompanion {
+  def benchName = "Loader"
+  def collectionName = "General"
+  def apply(sz: Int, p: Int, what: String) = new Loader(sz, p, what)
+  override def defaultSize = 100
+}
+
+
+class Loader(val size: Int, val parallelism: Int, val runWhat: String) extends Bench {
+  def companion = Loader
+
+  override def repetitionsPerRun = 1
+
+  reset
+
+  def runseq {
+    val m = Map(
+      '2' -> "ABC", '3' -> "DEF", '4' -> "GHI", '5' -> "JKL",
+      '6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ"
+    )
+    val charCode: Map[Char, Char] = for ((digit, letters) <- m; letter <- letters) yield letter -> digit
+    def wordCode(word: String): String = word.toUpperCase map charCode
+
+    Dictionary.wordarray groupBy wordCode
+  }
+
+  def runpar {
+    val m = Map(
+      '2' -> "ABC", '3' -> "DEF", '4' -> "GHI", '5' -> "JKL",
+      '6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ"
+    )
+    val charCode: Map[Char, Char] = for ((digit, letters) <- m; letter <- letters) yield letter -> digit
+    def wordCode(word: String): String = word.toUpperCase map charCode
+
+    Dictionary.wordarray.par groupBy wordCode
+  }
+
+  def reset = runWhat match {
+    case "seq" =>
+    case "par" =>
+      collection.parallel.tasksupport.environment.asInstanceOf[concurrent.forkjoin.ForkJoinPool].setParallelism(parallelism)
+  }
+
+  def comparisonMap = Map()
+
+}
+
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/GroupBy.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/GroupBy.scala
new file mode 100644
index 0000000000..abfba42b78
--- /dev/null
+++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/parallel_array/GroupBy.scala
@@ -0,0 +1,45 @@
+package scala.collection.parallel.benchmarks
+package parallel_array
+
+
+
+object GroupByLight extends Companion {
+  def benchName = "groupby-light";
+  def apply(sz: Int, parallelism: Int, what: String) = new GroupByLight(sz, parallelism, what)
+  override def comparisons = List()
+  override def defaultSize = 10000
+
+  val fun = (a: Cont) => a.in % 2
+}
+
+
+class GroupByLight(sz: Int, p: Int, what: String)
+extends Resettable(sz, p, what, new Cont(_), new Array[Any](_), classOf[Cont])
+with HavingResult[Int] {
+  def companion = GroupByLight
+  runresult = -1
+
+  val array = new Array[Cont](sz)
+  for (i <- 0 until sz) array(i) = new Cont(i)
+
+  def runpar = runresult = pa.groupBy(GroupByLight.fun).size
+  def runseq = runresult = array.asInstanceOf[Array[Cont]].groupBy(GroupByLight.fun).size
+  def comparisonMap = collection.Map()
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/files/scalacheck/parallel-collections/IntOperators.scala b/test/files/scalacheck/parallel-collections/IntOperators.scala
index 24330d7670..4a74b91da8 100644
--- a/test/files/scalacheck/parallel-collections/IntOperators.scala
+++ b/test/files/scalacheck/parallel-collections/IntOperators.scala
@@ -60,6 +60,10 @@ trait IntOperators extends Operators[Int] {
     Array.fill(1000)(1).toSeq
   )
   def newArray(sz: Int) = new Array[Int](sz)
+  def groupByFunctions = List(
+    _ % 2, _ % 3, _ % 5, _ % 10, _ % 154, _% 3217,
+    _ * 2, _ + 1
+  )
 }
 
 
diff --git a/test/files/scalacheck/parallel-collections/Operators.scala b/test/files/scalacheck/parallel-collections/Operators.scala
index b4321cf805..72133a5009 100644
--- a/test/files/scalacheck/parallel-collections/Operators.scala
+++ b/test/files/scalacheck/parallel-collections/Operators.scala
@@ -21,6 +21,7 @@ trait Operators[T] {
   def foldArguments: List[(T, (T, T) => T)]
   def addAllTraversables: List[Traversable[T]]
   def newArray(sz: Int): Array[T]
+  def groupByFunctions: List[T => T]
 }
 
 
diff --git a/test/files/scalacheck/parallel-collections/PairOperators.scala b/test/files/scalacheck/parallel-collections/PairOperators.scala
index 2055c29d38..fe851114be 100644
--- a/test/files/scalacheck/parallel-collections/PairOperators.scala
+++ b/test/files/scalacheck/parallel-collections/PairOperators.scala
@@ -73,6 +73,10 @@ trait PairOperators[K, V] extends Operators[(K, V)] {
 
   def newArray(sz: Int) = new Array[(K, V)](sz)
 
+  def groupByFunctions = (koperators.groupByFunctions zip voperators.groupByFunctions) map {
+    opt => { (p: (K, V)) => (opt._1(p._1), opt._2(p._2)) }
+  }
+
 }
 
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
index 60e8c8b1f2..9ddd5781b9 100644
--- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
@@ -414,6 +414,22 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
       }).reduceLeft(_ && _)
   }
 
+  // property("groupBy must be equal") = forAll(collectionPairs) {
+  //   case (t, coll) =>
+  //     (for ((f, ind) <- groupByFunctions.zipWithIndex) yield {
+  //       val tgroup = t.groupBy(f)
+  //       val cgroup = coll.groupBy(f)
+  //       if (tgroup != cgroup || cgroup != tgroup) {
+  //         println("from: " + t)
+  //         println("and: " + coll)
+  //         println("groups are: ")
+  //         println(tgroup)
+  //         println(cgroup)
+  //       }
+  //       ("operator " + ind) |: tgroup == cgroup && cgroup == tgroup
+  //     }).reduceLeft(_ && _)
+  // }
+
 }
 
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelVectorCheck.scala b/test/files/scalacheck/parallel-collections/ParallelVectorCheck.scala
new file mode 100644
index 0000000000..a2b6cef96d
--- /dev/null
+++ b/test/files/scalacheck/parallel-collections/ParallelVectorCheck.scala
@@ -0,0 +1,61 @@
+package scala.collection
+package parallel.immutable
+
+
+
+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._
+
+
+import immutable.Vector
+import immutable.VectorBuilder
+
+
+
+
+abstract class ParallelVectorCheck[T](tp: String) extends collection.parallel.ParallelSeqCheck[T]("ParVector[" + tp + "]") {
+  // ForkJoinTasks.defaultForkJoinPool.setMaximumPoolSize(Runtime.getRuntime.availableProcessors * 2)
+  // ForkJoinTasks.defaultForkJoinPool.setParallelism(Runtime.getRuntime.availableProcessors * 2)
+
+  type CollType = ParVector[T]
+
+  def isCheckingViews = false
+
+  def hasStrictOrder = true
+
+  def ofSize(vals: Seq[Gen[T]], sz: Int) = {
+    val vb = new immutable.VectorBuilder[T]()
+    val gen = vals(rnd.nextInt(vals.size))
+    for (i <- 0 until sz) vb += sample(gen)
+    vb.result
+  }
+
+  def fromSeq(a: Seq[T]) = {
+    val pa = ParVector.newCombiner[T]
+    for (elem <- a.toList) pa += elem
+    pa.result
+  }
+
+}
+
+
+
+object IntParallelVectorCheck extends ParallelVectorCheck[Int]("Int") with IntSeqOperators with IntValues {
+  override def instances(vals: Seq[Gen[Int]]) = oneOf(super.instances(vals), sized { sz =>
+    (0 until sz).toArray.toSeq
+  }, sized { sz =>
+    (-sz until 0).toArray.toSeq
+  })
+}
+
+
+
+
+
diff --git a/test/files/scalacheck/parallel-collections/pc.scala b/test/files/scalacheck/parallel-collections/pc.scala
index 075a76ca6a..598c5a3751 100644
--- a/test/files/scalacheck/parallel-collections/pc.scala
+++ b/test/files/scalacheck/parallel-collections/pc.scala
@@ -29,6 +29,7 @@ class ParCollProperties extends Properties("Parallel collections") {
   include(mutable.IntParallelHashSetCheck)
 
   // parallel vectors
+  include(immutable.IntParallelVectorCheck)
 
   /*   Views   */