From a1b86a7e513f16f93aa2bc4294664f46bcac95d9 Mon Sep 17 00:00:00 2001
From: Aleksandar Pokopec <aleksandar.prokopec@epfl.ch>
Date: Wed, 10 Nov 2010 16:21:28 +0000
Subject: Added a benchmark for mutable hash sets.

No review.
---
 test/benchmarks/source.list                        |   1 +
 .../hashtables/ParallelHashTableSets.scala         | 144 +++++++++++++++++++++
 2 files changed, 145 insertions(+)
 create mode 100644 test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTableSets.scala

(limited to 'test/benchmarks')

diff --git a/test/benchmarks/source.list b/test/benchmarks/source.list
index ff255cf11a..dffd5ef4ea 100644
--- a/test/benchmarks/source.list
+++ b/test/benchmarks/source.list
@@ -1,6 +1,7 @@
 src/scala/collection/parallel/Benchmarking.scala
 src/scala/collection/parallel/benchmarks/parallel_view/SeqViewBenches.scala
 src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTables.scala
+src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTableSets.scala
 src/scala/collection/parallel/benchmarks/arrays/ObjectAccess.scala
 src/scala/collection/parallel/benchmarks/arrays/IntAccess.scala
 src/scala/collection/parallel/benchmarks/arrays/Resetting.scala
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTableSets.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTableSets.scala
new file mode 100644
index 0000000000..2ac1e1c110
--- /dev/null
+++ b/test/benchmarks/src/scala/collection/parallel/benchmarks/hashtables/ParallelHashTableSets.scala
@@ -0,0 +1,144 @@
+package scala.collection.parallel.benchmarks.hashtables
+
+
+
+
+import scala.collection.parallel.benchmarks.generic.StandardParIterableBenches
+import scala.collection.parallel.benchmarks.generic.Dummy
+import scala.collection.parallel.benchmarks.generic.DummyOperators
+import scala.collection.parallel.mutable.ParHashSet
+
+
+
+
+
+trait ParHashTableSetBenches[T] extends StandardParIterableBenches[T, ParHashSet[T]] {
+
+  def nameOfCollection = "mutable.ParHashSet"
+  def comparisonMap = collection.mutable.Set()
+  val forkJoinPool = new scala.concurrent.forkjoin.ForkJoinPool
+
+  object Map2 extends IterableBenchCompanion {
+    override def defaultSize = 5000
+    override def comparisons = List()
+    def benchName = "map2";
+    def apply(sz: Int, p: Int, w: String) = new Map2(sz, p, w)
+  }
+
+  class Map2(val size: Int, val parallelism: Int, val runWhat: String)
+  extends IterableBench {
+    var result: Int = 0
+    def comparisonMap = collection.Map()
+    def runseq = {
+      val r = this.seqcoll.asInstanceOf[collection.mutable.HashSet[T]].map(operators.mapper2)
+      result = r.size
+    }
+    def runpar = {
+      result = this.parcoll.map(operators.mapper2).size
+    }
+    def companion = Map2
+    override def repetitionsPerRun = 50
+    override def printResults {
+      println("Size of last result: " + result)
+    }
+  }
+
+  object HeavyMap extends IterableBenchCompanion {
+    override def defaultSize = 5000
+    override def comparisons = List()
+    def benchName = "heavy-map";
+    def apply(sz: Int, p: Int, w: String) = new HeavyMap(sz, p, w)
+  }
+
+  class HeavyMap(val size: Int, val parallelism: Int, val runWhat: String)
+  extends IterableBench {
+    var result: Int = 0
+    def comparisonMap = collection.Map()
+    def runseq = {
+      val r = this.seqcoll.asInstanceOf[collection.mutable.HashSet[T]].map(operators.heavymapper)
+      result = r.size
+    }
+    def runpar = {
+      result = this.parcoll.map(operators.heavymapper).size
+    }
+    def companion = HeavyMap
+    override def repetitionsPerRun = 50
+  }
+
+  object Reduce2 extends IterableBenchCompanion {
+    override def defaultSize = 50000
+    override def comparisons = List()
+    def benchName = "reduce2";
+    def apply(sz: Int, p: Int, w: String) = new Reduce2(sz, p, w)
+  }
+
+  class Reduce2(val size: Int, val parallelism: Int, val runWhat: String)
+  extends IterableBench {
+    def comparisonMap = collection.Map()
+    def runseq = this.seqcoll.reduceLeft(operators.mediumreducer)
+    def runpar = this.parcoll.reduce(operators.mediumreducer)
+    def companion = Reduce2
+  }
+
+  object Foreach extends IterableBenchCompanion {
+    override def defaultSize = 50000
+    override def comparisons = List()
+    def benchName = "foreach";
+    def apply(sz: Int, p: Int, w: String) = new Foreach(sz, p, w)
+  }
+
+  class Foreach(val size: Int, val parallelism: Int, val runWhat: String)
+  extends IterableBench {
+    def comparisonMap = collection.Map()
+    def runseq = this.seqcoll.foreach(operators.foreachFun)
+    def runpar = this.parcoll.foreach(operators.foreachFun)
+    def companion = Foreach
+  }
+
+}
+
+
+
+
+
+object RefParHashTableSetBenches extends ParHashTableSetBenches[Dummy] {
+
+  object ForeachSet extends IterableBenchCompanion {
+    override def defaultSize = 50000
+    override def comparisons = List()
+    def benchName = "foreach-set";
+    def apply(sz: Int, p: Int, w: String) = new ForeachSet(sz, p, w)
+  }
+
+  class ForeachSet(val size: Int, val parallelism: Int, val runWhat: String)
+  extends IterableBench {
+    val array = new Array[Int](size)
+    def comparisonMap = collection.Map()
+    def runseq = for (x <- this.seqcoll) array(x.in) += 1
+    def runpar = for (x <- this.parcoll) array(x.in) += 1
+    def companion = ForeachSet
+
+    override def onEnd {
+      for (i <- 0 until array.length) {
+        assert(array(i) == repetitionsPerRun * runs)
+      }
+    }
+  }
+
+  val operators = DummyOperators
+
+  def createSequential(sz: Int, p: Int) = {
+    val ht = new collection.mutable.HashSet[Dummy]
+    for (i <- 0 until sz) ht += new Dummy(i)
+    ht
+  }
+
+  def createParallel(sz: Int, p: Int) = {
+    val phm = new ParHashSet[Dummy]
+    for (i <- 0 until sz) phm += new Dummy(i)
+    forkJoinPool.setParallelism(p)
+    phm.environment = forkJoinPool
+    phm
+  }
+
+}
-- 
cgit v1.2.3