MeasureTimeUtil.scala

package com.twitter.mrosenthal.timelines.adhoc.dataset_transform

import scala.collection.mutable
import scala.concurrent.duration._

object MeasureTimeUtil {
  
  def measureTime[T](numRepeats: Int)(f: => T): FiniteDuration = {
    f // warm up
    
    val startTime = System.currentTimeMillis()
    
    var i = 0
    while(i < numRepeats) {
      f
      i = i + 1
    }
    
    val endTime = System.currentTimeMillis()
    
    ((endTime - startTime).toDouble / numRepeats).millis
  }
}

object MeasureTimeExample extends App {
  
  val arr = Array.fill(10000)(1L)
  val vec = Vector.fill(10000)(1L)
  
  println( "random access arr " +
    MeasureTimeUtil.measureTime(10000){
      var i = 0
      while(i < 10000) {
        arr(i)
        i = i + 1
      }
    }
  )
  
  println( "random access vec " +
    MeasureTimeUtil.measureTime(10000){
      var i = 0
      while(i < 10000) {
        vec(i)
        i = i + 1
      }
    }
  )
  
  println( "random access arr with while " +
    MeasureTimeUtil.measureTime(10000){
      var i = 0
      while(i < 10000) {
        arr(i)
        i = i + 1
      }
    }
  )
  
  println( "random access arr with for " +
    MeasureTimeUtil.measureTime(10000) {
      for(i <- 0 until 10000) arr(i)
    }
  )
  
  println( "map arr imperative " +
    MeasureTimeUtil.measureTime(10000){
      var i = 0
      while(i < 10000) {
        arr.update(i, arr(i) * 2)
        i = i + 1
      }
    }
  )
  
  println( "map vec functional " +
    MeasureTimeUtil.measureTime(10000){
      vec.map(_ * 2)
    }
  )
  
  val keysValues = (0 until 10000).map(i => i -> i).toArray
  val(keys, values) = keysValues.unzip
  
  println( "insert to map imperative immutable " +
    MeasureTimeUtil.measureTime(1000){
      val initial = Map.empty[Int, Int]
      var cur = initial
      
      var i = 0
      while(i < 10000) {
        cur = cur + keysValues(i)
        i = i + 1
      }
    }
  )
  
  println( "insert to map imperative mutable " +
    MeasureTimeUtil.measureTime(1000){
      val map = mutable.Map.empty[Int, Int]
      
      var i = 0
      while(i < 10000) {
        map.put(keys(i), values(i))
        i = i + 1
      }
    }
  )
  
  println( "insert to map functional immutable " +
    MeasureTimeUtil.measureTime(1000){
      Map.empty[Int, Int] ++ keysValues
    }
  )
  
  
  println( "insert to map functional mutable " +
    MeasureTimeUtil.measureTime(1000){
      val map = mutable.Map.empty[Int, Int]
      for { i <- keysValues.indices } map.put(keys(i), values(i))
    }
  )
  
  
  println( "insert to map functional toMap " +
    MeasureTimeUtil.measureTime(1000){
      keysValues.toMap
    }
  )
}

random access arr 500 nanoseconds
random access vec 23700 nanoseconds
random access arr with while 500 nanoseconds
random access arr with for 50100 nanoseconds
map arr imperative 3 microseconds
map vec functional 79300 nanoseconds
insert to map imperative immutable 1989 microseconds
insert to map imperative mutable 652 microseconds
insert to map functional immutable 1845 microseconds
insert to map functional mutable 619 microseconds
insert to map functional toMap 1987 microseconds