Scala example source code file (Benchmarking.scala)

This example Scala source code file (Benchmarking.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Scala tags/keywords

array, array, benchcompanion, benchmarking, benchmarkregister, benchmarkregister, example, example, general, linkedhashset, must, pararray, pararray, running

The Scala Benchmarking.scala source code

package scala.collection.parallel


import scala.collection.mutable.LinkedHashSet

import benchmarks._


/**
 * All benchmarks are registered here.
 * 
 * @author prokopec
 */
trait BenchmarkRegister {
  
  val benchcreators = LinkedHashSet[BenchCompanion]()
  
  def register(companion: BenchCompanion) = benchcreators += companion
  
  // parallel array benchmarks
  register(parallel_array.ReduceLight)
  register(parallel_array.ReduceNew)
  register(parallel_array.ReduceList)
  register(parallel_array.ReducePrime)
  register(parallel_array.ReduceHeavy)
  register(parallel_array.CountLight)
  register(parallel_array.CountList)
  register(parallel_array.CountHeavy)
  register(parallel_array.ForeachLight)
  register(parallel_array.ForeachHeavy)
  register(parallel_array.SumLight)
  register(parallel_array.MinLight)
  register(parallel_array.MapLight)
  register(parallel_array.FilterLight)
  register(parallel_array.PartitionLight)
  register(parallel_array.PartialMapLight)
  register(parallel_array.FlatMapLight)
  register(parallel_array.PlusPlus)
  register(parallel_array.ForallLight)
  register(parallel_array.ForallQuickStop)
  register(parallel_array.ForallStop80k)
  register(parallel_array.ForallHeavy)
  register(parallel_array.ExistsLight)
  register(parallel_array.FindLight)
  register(parallel_array.TakeMany)
  register(parallel_array.DropMany)
  register(parallel_array.SliceMany)
  register(parallel_array.SliceMedium)
  register(parallel_array.SliceFew)
  register(parallel_array.SplitHalf)
  register(parallel_array.TakeWhileLight)
  register(parallel_array.SpanLight)
  register(parallel_array.CopyToArray)
  register(parallel_array.SegmentLength)
  register(parallel_array.IndexWhere)
  register(parallel_array.LastIndexWhere)
  register(parallel_array.Reverse)
  register(parallel_array.ReverseMap)
  register(parallel_array.SameElementsLong)
  register(parallel_array.Corresponds)
  register(parallel_array.DiffHalf)
  register(parallel_array.IntersectHalf)
  register(parallel_array.RemoveDuplicates)
  register(parallel_array.PatchHalf)
  register(parallel_array.PadToDouble)
  register(parallel_array.AggregateLight)
  register(parallel_array.ScanLight)
  register(parallel_array.ScanMedium)
  register(parallel_array.GroupByLight)
  register(parallel_array.MatrixMultiplication)
  
  // parallel views
  register(parallel_view.DummyViewBenchList.Reduce)
  register(parallel_view.DummyViewBenchList.MediumReduce)
  register(parallel_view.DummyViewBenchList.ModifyThenReduce)
  register(parallel_view.DummyViewBenchList.ModifyThenForce)
  register(parallel_view.DummyViewBenchList.Iteration)
  register(parallel_view.DummyViewBenchList.IterationS)
  register(parallel_view.DummyViewBenchList.IterationM)
  register(parallel_view.DummyViewBenchList.IterationA)
  register(parallel_view.DummyViewBenchList.IterationZ)
  register(parallel_view.DummyViewBenchList.IterationP)
  
  // parallel ranges
  register(parallel_range.RangeBenches.Reduce)
  register(parallel_range.RangeBenches.ReduceMedium)
  register(parallel_range.RangeBenches.ForeachAdd)
  register(parallel_range.RangeBenches.ForeachAddCollatz)
  register(parallel_range.RangeBenches.ForeachModify)
  register(parallel_range.RangeBenches.ForeachModifyMedium)
  register(parallel_range.RangeBenches.ForeachModifyHeavy)
  register(parallel_range.RangeBenches.MapLight)
  register(parallel_range.RangeBenches.MapMedium)
  
  // array benchmarks
  register(arrays.ObjectAccess)
  register(arrays.IntAccess)
  
  // hash benchmarks
  register(hashtries.Foreach)
  register(hashtries.Iterate)
  register(hashtries.Construct)
  register(hashtries.Lookup)
  register(hashtries.Combine)
  register(hashtries.MultipleCombine)
  
  // parallel hash trie benchmarks
  register(hashtries.RefParHashTrieBenches.Reduce)
  register(hashtries.RefParHashTrieBenches.ReduceMedium)
  register(hashtries.RefParHashTrieBenches.Reduce2)
  register(hashtries.RefParHashTrieBenches.Map)
  register(hashtries.RefParHashTrieBenches.Map2)
  
  // parallel hash table map benchmarks
  register(hashtables.RefParHashTableBenches.Reduce)
  register(hashtables.RefParHashTableBenches.Reduce2)
  register(hashtables.RefParHashTableBenches.Foreach)
  register(hashtables.RefParHashTableBenches.ForeachSet)
  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)
  register(hashtables.RefParHashTableSetBenches.Reduce2)
  register(hashtables.RefParHashTableSetBenches.Foreach)
  register(hashtables.RefParHashTableSetBenches.ForeachSet)
  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)
  register(misc.Loader)
}


/**
 * Serves as an entrypoint to run all the benchmarks.
 */
object Benchmarking extends BenchmarkRegister {
  
  def printHelp {
    println("Must enter at least four arguments: <collection>   ")
    println("  Example: ParArray reduce-light 50000 par")
    println("  Example: ParArray -all 50000 par")
    println
    println("General synthax: <collection>    ")
    println("          <collection>  - name of the collection to test, `-all` runs benchmarks for all collections")
    println("           <benchmark>  - name of the specific benchmark, `-all` runs all benchmarks for the chosen collections")
    println("                <size>  - the size (number of elements) of the collection, or `-default` for default size per benchmark")
    println("                <type>  - `seq` for benchmarking sequential version of the functionality")
    println("                          `par` for benchmarking parallel version of the functionality")
    println("                          `<something-else>` for running comparison benchmarks")
    println("                          `-all` for running sequential, parallel and comparison benchmarks")
    println("   <parallelism-level>  - the level of parallelism used (default 2)")
  }
  
  def otherOptions(args: Array[String]) {
    if (args.length == 0) printHelp
    else args(0) match {
      case "-list" => // lists all benchmarks
        for (bc <- benchcreators) println(bc.fullname)
      case _ => printHelp
    }
  }
  
  def main(args: Array[String]) {
    if (args.length < 4) {
      otherOptions(args)
      return
    }
    
    val collname = args(0)
    val benchname = args(1)
    val size = if (args(2) == "-default") -1 else args(2).toInt
    val tpe = args(3)
    val parlevel = if (args.length >= 5) args(4).toInt else 2
    
    // find all benchmarks to run
    val benches = benchcreators.filter(comp => {
      (collname, benchname) match {
        case ("-all", "-all") => true
        case ("-all", bn) if (benchname != "-all") => bn == comp.benchName
        case (cn, "-all") if (collname != "-all") => cn == comp.collectionName
        case (cn, bn) => cn == comp.collectionName && bn == comp.benchName
      }
    }).flatMap(comp => {
      val collsz = if (size != -1) size else comp.defaultSize
      if (tpe != "-all") List(comp.apply(collsz, parlevel, tpe))
      else for (benchtype <- "seq" :: "par" :: comp.comparisons) 
        yield comp.apply(collsz, parlevel, benchtype)
    })
    
    println("Running benchmarks...")
    for (b <- benches) b.executeBenchmark
  }
  
}