summaryrefslogtreecommitdiff
path: root/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala
diff options
context:
space:
mode:
Diffstat (limited to 'test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala')
-rw-r--r--test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala362
1 files changed, 0 insertions, 362 deletions
diff --git a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala b/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala
deleted file mode 100644
index c39c384927..0000000000
--- a/test/benchmarks/src/scala/collection/parallel/benchmarks/generic/ParallelBenches.scala
+++ /dev/null
@@ -1,362 +0,0 @@
-package scala.collection.parallel
-package benchmarks
-package generic
-
-
-
-import scala.collection.SeqView
-
-
-
-trait ParIterableBenches[T, Coll <: ParIterable[T]] {
-self =>
-
- def createSequential(sz: Int, p: Int): Iterable[T]
- def createParallel(sz: Int, p: Int): Coll
- def nameOfCollection: String
- def operators: Operators[T]
-
- trait IterableBenchCompanion extends BenchCompanion {
- def collectionName = self.nameOfCollection
- }
-
- trait IterableBench extends collection.parallel.benchmarks.Bench {
- protected var seqcoll: Iterable[T] = null
- protected var parcoll: Coll = null.asInstanceOf[Coll]
-
- reset
-
- def reset = runWhat match {
- case "seq" => this.seqcoll = createSequential(size, parallelism)
- case "par" => this.parcoll = createParallel(size, parallelism)
- case _ =>
- }
-
- def nameOfCollection = self.nameOfCollection
- def operators = self.operators
- def createSequential(sz: Int, p: Int) = self.createSequential(size, parallelism)
- def createParallel(sz: Int, p: Int) = self.createParallel(size, parallelism)
- def forkJoinPool: scala.concurrent.forkjoin.ForkJoinPool = self.forkJoinPool
-
- override def printResults {
- println(" --- Fork join pool state --- ")
- println("Parallelism: " + forkJoinPool.getParallelism)
- println("Active threads: " + forkJoinPool.getActiveThreadCount)
- println("Work stealings: " + forkJoinPool.getStealCount)
- }
-
- }
-
- def forkJoinPool: scala.concurrent.forkjoin.ForkJoinPool
-
-}
-
-
-trait ParSeqBenches[T, Coll <: ParSeq[T]] extends ParIterableBenches[T, Coll] {
-self =>
-
- def createSequential(sz: Int, p: Int): Seq[T]
-
- trait SeqBenchCompanion extends BenchCompanion {
- def collectionName = self.nameOfCollection
- }
-
- trait SeqBench extends IterableBench {
- def seqcollAsSeq = seqcoll.asInstanceOf[Seq[T]]
- override def createSequential(sz: Int, p: Int) = self.createSequential(sz, p)
- }
-
-}
-
-
-
-
-/** Standard benchmarks for collections.
- */
-trait StandardParIterableBenches[T, Coll <: ParIterable[T]] extends ParIterableBenches[T, Coll] {
-
- object Reduce extends IterableBenchCompanion {
- override def defaultSize = 50000
- def benchName = "reduce";
- def apply(sz: Int, p: Int, w: String) = new Reduce(sz, p, w)
- }
-
- class Reduce(val size: Int, val parallelism: Int, val runWhat: String)
- extends IterableBench {
- def comparisonMap = collection.Map()
- def runseq = this.seqcoll.reduceLeft(operators.reducer)
- def runpar = this.parcoll.reduce(operators.reducer)
- def companion = Reduce
- }
-
- object ReduceMedium extends IterableBenchCompanion {
- override def defaultSize = 5000
- def benchName = "reduce-medium";
- def apply(sz: Int, p: Int, w: String) = new ReduceMedium(sz, p, w)
- }
-
- class ReduceMedium(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 = ReduceMedium
- }
-
- object Map extends IterableBenchCompanion {
- override def defaultSize = 5000
- def benchName = "map";
- def apply(sz: Int, p: Int, w: String) = new Map(sz, p, w)
- }
-
- class Map(val size: Int, val parallelism: Int, val runWhat: String)
- extends IterableBench {
- def comparisonMap = collection.Map()
- def runseq = this.seqcoll.map(operators.mapper)
- def runpar = this.parcoll.map(operators.mapper)
- 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
- }
-
-}
-
-
-
-/** Benchmarks for sequence views.
- */
-trait ParSeqViewBenches[T, Coll <: ParSeqView[T, ParSeq[T], CollSeq], CollSeq] extends ParSeqBenches[T, Coll] {
-self =>
-
- trait SeqViewBench extends SeqBench {
- lazy val seqview: SeqView[T, Seq[T]] = createSeqView(size, parallelism)
-
- def createSeqView(sz: Int, p: Int) = self.createSeqView(sz, p)
- }
-
- def createSeqView(sz: Int, p: Int): SeqView[T, Seq[T]]
-
- object Iteration extends SeqBenchCompanion {
- override def defaultSize = 250000
- def benchName = "iter"
- def apply(sz: Int, p: Int, w: String) = new Iteration(sz, p, w)
- }
-
- class Iteration(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = this.seqcoll.foreach(operators.eachFun)
- def runpar = this.parcoll.pforeach(operators.eachFun)
- def runseqview = {
- this.seqview.foreach(operators.eachFun)
- }
- def companion = Iteration
- }
-
- object IterationS extends SeqBenchCompanion {
- override def defaultSize = 250000
- def benchName = "iter-s"
- def apply(sz: Int, p: Int, w: String) = new IterationS(sz, p, w)
- }
-
- class IterationS(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = this.seqcoll.slice(0, size / 2).foreach(operators.eachFun)
- def runpar = this.parcoll.slice(0, size / 2).pforeach(operators.eachFun)
- def runseqview = this.seqview.slice(0, size / 2).foreach(operators.eachFun)
- def companion = IterationS
- }
-
- object IterationM extends SeqBenchCompanion {
- override def defaultSize = 100000
- def benchName = "iter-m"
- def apply(sz: Int, p: Int, w: String) = new IterationM(sz, p, w)
- }
-
- class IterationM(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = this.seqcoll.map(operators.mapper).foreach(operators.eachFun)
- def runpar = this.parcoll.map(operators.mapper).pforeach(operators.eachFun)
- def runseqview = this.seqview.map(operators.mapper).foreach(operators.eachFun)
- def companion = IterationM
- }
-
- object IterationA extends SeqBenchCompanion {
- override def defaultSize = 50000
- def benchName = "iter-a"
- def apply(sz: Int, p: Int, w: String) = new IterationA(sz, p, w)
- }
-
- class IterationA(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- val appended = operators.sequence(size)
- val sqappended = appended.toSeq
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = {
- val withapp = this.seqcoll.++(sqappended)
- withapp.foreach(operators.eachFun)
- }
- def runpar = this.parcoll.++(appended).pforeach(operators.eachFun)
- def runseqview = this.seqview.++(appended).foreach(operators.eachFun)
- def companion = IterationA
- }
-
- object IterationZ extends SeqBenchCompanion {
- override def defaultSize = 50000
- def benchName = "iter-z"
- def apply(sz: Int, p: Int, w: String) = new IterationZ(sz, p, w)
- }
-
- class IterationZ(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- val zipped = operators.sequence(size)
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = {
- val withzip = this.seqcoll.zip(zipped)
- withzip.foreach(operators.eachPairFun)
- }
- def runpar = this.parcoll.zip(zipped).pforeach(operators.eachPairFun)
- def runseqview = this.seqview.zip(zipped).foreach(operators.eachPairFun)
- def companion = IterationZ
- }
-
- object IterationP extends SeqBenchCompanion {
- override def defaultSize = 50000
- def benchName = "iter-p"
- def apply(sz: Int, p: Int, w: String) = new IterationP(sz, p, w)
- }
-
- class IterationP(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- val patch = operators.sequence(size / 4)
- val sqpatch = patch.toSeq
- def comparisonMap = collection.Map("seqview" -> runseqview _)
- def runseq = {
- val withpatch = this.seqcollAsSeq.patch(size / 4, sqpatch, size / 2)
- withpatch.foreach(operators.eachFun)
- }
- def runpar = this.parcoll.patch(size / 4, patch, size / 2).pforeach(operators.eachFun)
- def runseqview = this.seqview.patch(size / 4, patch, size / 2).foreach(operators.eachFun)
- def companion = IterationP
- }
-
- object Reduce extends SeqBenchCompanion {
- override def defaultSize = 50000
- def benchName = "reduce";
- def apply(sz: Int, p: Int, w: String) = new Reduce(sz, p, w)
- }
-
- class Reduce(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- def comparisonMap = collection.Map()
- def runseq = this.seqcoll.reduceLeft(operators.reducer)
- def runpar = this.parcoll.reduce(operators.reducer)
- def companion = Reduce
- }
-
- object MediumReduce extends SeqBenchCompanion {
- override def defaultSize = 50000
- def benchName = "reduce-medium";
- def apply(sz: Int, p: Int, w: String) = new MediumReduce(sz, p, w)
- }
-
- class MediumReduce(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- def comparisonMap = collection.Map()
- def runseq = this.seqcoll.reduceLeft(operators.mediumreducer)
- def runpar = this.parcoll.reduce(operators.mediumreducer)
- def companion = Reduce
- }
-
- object ModifyThenReduce extends SeqBenchCompanion {
- override def defaultSize = 20000
- def benchName = "modify-then-reduce";
- def apply(sz: Int, p: Int, w: String) = new ModifyThenReduce(sz, p, w)
- }
-
- class ModifyThenReduce(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- val toadd = createSequential(size, parallelism)
- def comparisonMap = collection.Map()
- def runseq = {
- val modified = (seqcoll ++ toadd).drop(size).map(operators.mapper).++(toadd).take(size)
- modified.reduceLeft(operators.reducer)
- }
- def runpar = {
- val modified = (parcoll ++ toadd).drop(size).map(operators.mapper).++(toadd).take(size)
- modified.reduce(operators.reducer)
- }
- def companion = ModifyThenReduce
- }
-
- object ModifyThenForce extends SeqBenchCompanion {
- override def defaultSize = 20000
- def benchName = "modify-then-force";
- def apply(sz: Int, p: Int, w: String) = new ModifyThenForce(sz, p, w)
- }
-
- class ModifyThenForce(val size: Int, val parallelism: Int, val runWhat: String)
- extends SeqBench with SeqViewBench {
- val toadd = createSequential(size, parallelism)
- def comparisonMap = collection.Map()
- def runseq = (seqcoll ++ toadd).drop(size).map(operators.mapper).++(toadd).take(size)
- def runpar = {
- val r: ParSeqView[T, ParSeq[T], Seq[T]] = (parcoll ++ toadd).drop(size).map(operators.mapper).++(toadd).take(size)
- r.force
- }
- def companion = ModifyThenForce
- }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-04 03:34:29 +0000