diff options
author | Martin Odersky <odersky@gmail.com> | 2016-02-04 18:06:03 +0100 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2016-02-04 18:06:03 +0100 |
commit | fc4867eafbf9714bfd053cc594b6763197859001 (patch) | |
tree | b1af2d7453c84dd858ab77104f104528c884aa06 /tests/disabled/run/t5293-map.scala | |
parent | 6778e3c74ff86c0174e84bb3df08af47931ecbbb (diff) | |
download | dotty-fc4867eafbf9714bfd053cc594b6763197859001.tar.gz dotty-fc4867eafbf9714bfd053cc594b6763197859001.tar.bz2 dotty-fc4867eafbf9714bfd053cc594b6763197859001.zip |
Disable benchmark test
The test checks that Scala collections perform within 10x of Java collections.
That's not something we need to test for dotty. And because of the heavily
parallel execution of the tests it does not always hold. This is the second
time in a a month that this particular test failed on jenkins. I think we lost
enough cycles on it.
Diffstat (limited to 'tests/disabled/run/t5293-map.scala')
-rw-r--r-- | tests/disabled/run/t5293-map.scala | 88 |
1 files changed, 88 insertions, 0 deletions
diff --git a/tests/disabled/run/t5293-map.scala b/tests/disabled/run/t5293-map.scala new file mode 100644 index 000000000..1ef7d97e5 --- /dev/null +++ b/tests/disabled/run/t5293-map.scala @@ -0,0 +1,88 @@ + + + +import scala.collection.JavaConverters._ + + + +object Test extends dotty.runtime.LegacyApp { + + def bench(label: String)(body: => Unit): Long = { + val start = System.nanoTime + + 0.until(10).foreach(_ => body) + + val end = System.nanoTime + + //println("%s: %s ms".format(label, (end - start) / 1000.0 / 1000.0)) + + end - start + } + + def benchJava(values: java.util.Map[Int, Int]) = { + bench("Java Map") { + val m = new java.util.HashMap[Int, Int] + + m.putAll(values) + } + } + + def benchScala(values: Iterable[(Int, Int)]) = { + bench("Scala Map") { + val m = new scala.collection.mutable.HashMap[Int, Int] + + m ++= values + } + } + + def benchScalaSorted(values: Iterable[(Int, Int)]) = { + bench("Scala Map sorted") { + val m = new scala.collection.mutable.HashMap[Int, Int] + + m ++= values.toArray.sorted + } + } + + def benchScalaPar(values: Iterable[(Int, Int)]) = { + bench("Scala ParMap") { + val m = new scala.collection.parallel.mutable.ParHashMap[Int, Int] map { x => x } + + m ++= values + } + } + + val total = 50000 + val values = (0 until total) zip (0 until total) + val map = scala.collection.mutable.HashMap.empty[Int, Int] + + map ++= values + + // warmup + for (x <- 0 until 5) { + benchJava(map.asJava) + benchScala(map) + benchScalaPar(map) + benchJava(map.asJava) + benchScala(map) + benchScalaPar(map) + } + + val javamap = benchJava(map.asJava) + val scalamap = benchScala(map) + val scalaparmap = benchScalaPar(map) + + // println(javamap) + // println(scalamap) + // println(scalaparmap) + + assert(scalamap < (javamap * 10), "scalamap: " + scalamap + " vs. javamap: " + javamap) + assert(scalaparmap < (javamap * 10), "scalaparmap: " + scalaparmap + " vs. javamap: " + javamap) +} + + + + + + + + |