From 78a48c46cf3727dd06179cb1360b2f9057647042 Mon Sep 17 00:00:00 2001 From: Aleksandar Pokopec Date: Wed, 26 Jan 2011 08:37:23 +0000 Subject: Merge branch 'work' Conflicts: src/library/scala/concurrent/SyncVar.scala --- .../scala/collection/parallel/Benchmarking.scala | 5 ++++ .../parallel/benchmarks/generic/Dummy.scala | 3 ++ .../parallel/benchmarks/generic/Operators.scala | 4 +++ .../benchmarks/generic/ParallelBenches.scala | 28 ++++++++++++++++++ .../benchmarks/hashtables/ParallelHashTables.scala | 18 ++++++++++++ .../benchmarks/hashtries/ParallelHashTries.scala | 3 ++ test/files/jvm/serialization.scala | 4 +-- test/files/pos/scan.scala | 23 --------------- test/files/run/UnrolledBuffer.scala | 2 +- test/files/run/scan.scala | 23 +++++++++++++++ test/files/run/testblock.scala | 33 ++++++++++++++++++++++ test/files/run/testpar.scala | 24 ++++++++++++++++ test/files/scalacheck/Unrolled.scala | 2 +- 13 files changed, 145 insertions(+), 27 deletions(-) delete mode 100644 test/files/pos/scan.scala create mode 100644 test/files/run/scan.scala create mode 100644 test/files/run/testblock.scala create mode 100644 test/files/run/testpar.scala (limited to 'test') diff --git a/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala b/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala index e413fb537e..c3811601e3 100644 --- a/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala +++ b/test/benchmarks/src/scala/collection/parallel/Benchmarking.scala @@ -119,6 +119,9 @@ trait BenchmarkRegister { register(hashtables.RefParHashTableBenches.Map) register(hashtables.RefParHashTableBenches.Map2) register(hashtables.RefParHashTableBenches.HeavyMap) + register(hashtables.RefParHashTableBenches.Filter) + register(hashtables.RefParHashTableBenches.FlatMap) + register(hashtables.RefParHashTableBenches.FlatMap2) // parallel hash table set benchmarks register(hashtables.RefParHashTableSetBenches.Reduce) @@ -128,6 +131,8 @@ trait BenchmarkRegister { register(hashtables.RefParHashTableSetBenches.Map) register(hashtables.RefParHashTableSetBenches.Map2) register(hashtables.RefParHashTableSetBenches.HeavyMap) + register(hashtables.RefParHashTableSetBenches.Filter) + register(hashtables.RefParHashTableSetBenches.FlatMap) // general examples register(misc.Coder) diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Dummy.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Dummy.scala index 7cb3641622..3b5308f8c2 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Dummy.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Dummy.scala @@ -58,6 +58,9 @@ object DummyOperators extends Operators[Dummy] { } a } + val flatmapper = (a: Dummy) => { + List(a, a, a, a, a) + } val taker = (a: Dummy) => { a.in >= 0 } diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Operators.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Operators.scala index 84f69239f6..4fb76542e1 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Operators.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/Operators.scala @@ -14,6 +14,7 @@ trait Operators[T] { def mapper: T => T def mapper2: T => T = error("unsupported") def heavymapper: T => T + def flatmapper: T => Seq[T] def taker: T => Boolean def eachFun: T => Unit def eachPairFun: ((T, T)) => Unit = error("unsupported") @@ -44,6 +45,9 @@ trait IntOperators extends Operators[Int] { } n + sum } + val flatmapper: Int => Seq[Int] = (n: Int) => { + List(n, n, n, n, n) + } val taker: Int => Boolean = _ < 10000 val eachFun: Int => Unit = { n => n % 2 == 0 diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala index c0545aff52..b14a0b3aab 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala @@ -117,6 +117,34 @@ trait StandardParIterableBenches[T, Coll <: ParIterable[T]] extends ParIterableB def companion = Map } + object Filter extends IterableBenchCompanion { + override def defaultSize = 5000 + def benchName = "filter"; + def apply(sz: Int, p: Int, w: String) = new Filter(sz, p, w) + } + + class Filter(val size: Int, val parallelism: Int, val runWhat: String) + extends IterableBench { + def comparisonMap = collection.Map() + def runseq = this.seqcoll.filter(operators.filterer) + def runpar = this.parcoll.filter(operators.filterer) + def companion = Filter + } + + object FlatMap extends IterableBenchCompanion { + override def defaultSize = 5000 + def benchName = "flatmap"; + def apply(sz: Int, p: Int, w: String) = new FlatMap(sz, p, w) + } + + class FlatMap(val size: Int, val parallelism: Int, val runWhat: String) + extends IterableBench { + def comparisonMap = collection.Map() + def runseq = this.seqcoll.flatMap(operators.flatmapper) + def runpar = this.parcoll.flatMap(operators.flatmapper) + def companion = FlatMap + } + } diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTables.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTables.scala index cf0e53e47d..bdb1dff56d 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTables.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTables.scala @@ -57,6 +57,21 @@ trait ParHashTableBenches[K, V] extends StandardParIterableBenches[(K, V), ParHa } } + object FlatMap2 extends IterableBenchCompanion { + override def defaultSize = 5000 + def benchName = "flatmap2"; + def apply(sz: Int, p: Int, w: String) = new FlatMap2(sz, p, w) + } + + class FlatMap2(val size: Int, val parallelism: Int, val runWhat: String) + extends IterableBench { + def comparisonMap = collection.Map() + override def repetitionsPerRun = 25 + def runseq = this.seqcoll.flatMap(operators.flatmapper) + def runpar = this.parcoll.flatMap(operators.flatmapper) + def companion = FlatMap2 + } + object HeavyMap extends IterableBenchCompanion { override def defaultSize = 5000 override def comparisons = List() @@ -177,6 +192,9 @@ object RefParHashTableBenches extends ParHashTableBenches[Dummy, Dummy] { a.num = a.in % 2 (a, p._2) } + val flatmapper = (p: DPair) => { + for (i <- 0 until 20) yield p + } override val mapper2 = (p: DPair) => { val a = 1 //heavy(p._1.in) (new Dummy(p._1.in * -2 + a), p._2) diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtries/ParallelHashTries.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtries/ParallelHashTries.scala index 81d4f095da..3976b72d1a 100644 --- a/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtries/ParallelHashTries.scala +++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtries/ParallelHashTries.scala @@ -135,6 +135,9 @@ object RefParHashTrieBenches extends ParHashTrieBenches[Dummy, Dummy] { a.num = a.in % 2 (a, p._2) } + val flatmapper = (p: DPair) => { + List(p, p, p, p, p) + } override val mapper2 = (p: DPair) => { val a = 1 //heavy(p._1.in) (new Dummy(p._1.in * -2 + a), p._2) diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization.scala index 8c4df8fc37..6a4e37bda9 100644 --- a/test/files/jvm/serialization.scala +++ b/test/files/jvm/serialization.scala @@ -604,9 +604,9 @@ object Test9_parallel { println() // UnrolledBuffer - val ub = new UnrolledBuffer[String] + val ub = new collection.mutable.UnrolledBuffer[String] ub ++= List("one", "two") - val _ub: UnrolledBuffer[String] = read(write(ub)) + val _ub: collection.mutable.UnrolledBuffer[String] = read(write(ub)) check(ub, _ub) // mutable.ParArray diff --git a/test/files/pos/scan.scala b/test/files/pos/scan.scala deleted file mode 100644 index 47e0a7d976..0000000000 --- a/test/files/pos/scan.scala +++ /dev/null @@ -1,23 +0,0 @@ - - - - -object Test { - - def main(args: Array[String]) { - val lst = List(1, 2, 3, 4, 5) - - assert(lst.scanLeft(0)(_ + _) == List(0, 1, 3, 6, 10, 15)) - assert(lst.scanRight(0)(_ + _) == List(15, 14, 12, 9, 5, 0)) - - val emp = List[Int]() - assert(emp.scanLeft(0)(_ + _) == List(0)) - assert(emp.scanRight(0)(_ + _) == List(0)) - - val stream = Stream(1, 2, 3, 4, 5) - assert(stream.scanLeft(0)(_ + _) == Stream(0, 1, 3, 6, 10, 15)) - - assert(Stream.from(1).scanLeft(0)(_ + _).take(5) == Stream(0, 1, 3, 6, 10)) - } - -} \ No newline at end of file diff --git a/test/files/run/UnrolledBuffer.scala b/test/files/run/UnrolledBuffer.scala index 7e113c3e04..62a1f7d083 100644 --- a/test/files/run/UnrolledBuffer.scala +++ b/test/files/run/UnrolledBuffer.scala @@ -2,7 +2,7 @@ -import collection.parallel.UnrolledBuffer +import collection.mutable.UnrolledBuffer diff --git a/test/files/run/scan.scala b/test/files/run/scan.scala new file mode 100644 index 0000000000..47e0a7d976 --- /dev/null +++ b/test/files/run/scan.scala @@ -0,0 +1,23 @@ + + + + +object Test { + + def main(args: Array[String]) { + val lst = List(1, 2, 3, 4, 5) + + assert(lst.scanLeft(0)(_ + _) == List(0, 1, 3, 6, 10, 15)) + assert(lst.scanRight(0)(_ + _) == List(15, 14, 12, 9, 5, 0)) + + val emp = List[Int]() + assert(emp.scanLeft(0)(_ + _) == List(0)) + assert(emp.scanRight(0)(_ + _) == List(0)) + + val stream = Stream(1, 2, 3, 4, 5) + assert(stream.scanLeft(0)(_ + _) == Stream(0, 1, 3, 6, 10, 15)) + + assert(Stream.from(1).scanLeft(0)(_ + _).take(5) == Stream(0, 1, 3, 6, 10)) + } + +} \ No newline at end of file diff --git a/test/files/run/testblock.scala b/test/files/run/testblock.scala new file mode 100644 index 0000000000..a334b668fd --- /dev/null +++ b/test/files/run/testblock.scala @@ -0,0 +1,33 @@ + + + + +import scala.parallel._ + + + + +object Test { + + def main(args: Array[String]) { + if (util.Properties.isJavaAtLeast("1.6")) { + val vendor = util.Properties.javaVmVendor + if ((vendor contains "Sun") || (vendor contains "Apple")) blockcomp(10) + } + } + + val lock = new java.util.concurrent.locks.ReentrantLock + + def blockcomp(n: Int): Unit = if (n > 0) { + val (x, y) = par(blockcomp(n - 1), blockcomp(n - 1)) + if (n == 8) blocking { // without this blocking block, deadlock occurs + lock.lock() + } + x() + y() + if (n == 8) { + lock.unlock() + } + } + +} diff --git a/test/files/run/testpar.scala b/test/files/run/testpar.scala new file mode 100644 index 0000000000..c4c813ee00 --- /dev/null +++ b/test/files/run/testpar.scala @@ -0,0 +1,24 @@ + + + +import scala.parallel._ + + + + + +object Test { + + def main(args: Array[String]) { + if (util.Properties.isJavaAtLeast("1.6")) { + val vendor = util.Properties.javaVmVendor + if ((vendor contains "Sun") || (vendor contains "Apple")) assert(fib(40) == 102334155) + } + } + + def fib(n: Int): Int = if (n < 3) 1 else if (n < 35) fib(n - 1) + fib(n - 2) else { + val (p, pp) = par(fib(n - 1), fib(n - 2)) + p() + pp() + } + +} diff --git a/test/files/scalacheck/Unrolled.scala b/test/files/scalacheck/Unrolled.scala index d69e62dd01..34604b8667 100644 --- a/test/files/scalacheck/Unrolled.scala +++ b/test/files/scalacheck/Unrolled.scala @@ -2,7 +2,7 @@ import org.scalacheck._ import Prop._ import Gen._ -import collection.parallel.UnrolledBuffer +import collection.mutable.UnrolledBuffer object Test extends Properties("UnrolledBuffer") { -- cgit v1.2.3