All Downloads are FREE. Search and download functionalities are using the official Maven repository.

spire.benchmark.CForBenchmark.scala Maven / Gradle / Ivy

The newest version!
package spire.benchmark

import scala.{specialized => spec}
import scala.annotation.tailrec

import scala.util.Random
import Random._

import com.google.caliper.Runner 
import com.google.caliper.SimpleBenchmark
import com.google.caliper.Param

import spire.syntax.cfor._

object CForBenchmarks extends MyRunner(classOf[CForBenchmarks])

class CForBenchmarks extends MyBenchmark {
  //@Param(Array("10", "15", "20", "25"))
  //@Param(Array("1000", "10000", "100000", "1000000"))
  @Param(Array("1000000"))
  var size: Int = 0

  var arr: Array[Long] = null

  override protected def setUp() {
    arr = init(size)(scala.math.abs(nextInt - 1).toInt + 1)
  }

  @tailrec final def gcd(a: Long, b: Long): Long = if (a % b == 0) b else gcd(b, a % b)
  final def min(a: Long, b: Long): Long = if (a < b) a else b
  final def or(a: Long, b: Long): Long = a | b

  def timeWhileOr(reps:Int) = run(reps)(doWhileOr)
  def timeTailrecOr(reps:Int) = run(reps)(doTailrecOr)
  def timeForeachOr(reps:Int) = run(reps)(doForeachOr)
  def timeForOr(reps:Int) = run(reps)(doForOr)
  def timeCForOr(reps:Int) = run(reps)(doCForOr)

  def timeWhileMin(reps:Int) = run(reps)(doWhileMin)
  def timeTailrecMin(reps:Int) = run(reps)(doTailrecMin)
  def timeForeachMin(reps:Int) = run(reps)(doForeachMin)
  def timeForMin(reps:Int) = run(reps)(doForMin)
  def timeCForMin(reps:Int) = run(reps)(doCForMin)

  def timeWhileGcd(reps:Int) = run(reps)(doWhileGcd)
  def timeTailrecGcd(reps:Int) = run(reps)(doTailrecGcd)
  def timeForeachGcd(reps:Int) = run(reps)(doForeachGcd)
  def timeForGcd(reps:Int) = run(reps)(doForGcd)
  def timeCForGcd(reps:Int) = run(reps)(doCForGcd)

  def timeWhileIntArrayMultiply(reps:Int) = run(reps)(doWhileIntArrayMultiply)
  def timeTailrecIntArrayMultiply(reps:Int) = run(reps)(doTailrecIntArrayMultiply)
  def timeForeachIntArrayMultiply(reps:Int) = run(reps)(doForeachGcd)
  def timeForIntArrayMultiply(reps:Int) = run(reps)(doForGcd)
  def timeCForIntArrayMultiply(reps:Int) = run(reps)(doCForIntArrayMultiply)

  def doWhileOr {
    var t: Long = 0L
    var i: Int = 0
    val len = size - 1
    while (i < len) { t = t ^ or(arr(i), arr(i + 1)); i += 1 }

    i = 0
    val len2 = size / 2
    while (i < len2) { t = t ^ or(arr(i + 3), arr(i + 2)); i += 1 }

    i = 0
    val len3 = size / 3
    while (i < len3) { t = t ^ or(arr(i + 1), arr(i + 2)); i += 1 }
  }

  def doWhileMin {
    var t: Long = 0L
    var i: Int = 0
    val len = size - 1
    while (i < len) { t = t ^ min(arr(i), arr(i + 1)); i += 1 }

    i = 0
    val len2 = size / 2
    while (i < len2) { t = t ^ min(arr(i + 3), arr(i + 2)); i += 1 }

    i = 0
    val len3 = size / 3
    while (i < len3) { t = t ^ min(arr(i + 1), arr(i + 2)); i += 1 }
  }

  def doWhileGcd {
    var t: Long = 0L
    var i: Int = 0
    val len = size - 1
    while (i < len) { t = t ^ gcd(arr(i), arr(i + 1)); i += 1 }

    i = 0
    val len2 = size / 2
    while (i < len2) { t = t ^ gcd(arr(i + 3), arr(i + 2)); i += 1 }

    i = 0
    val len3 = size / 3
    while (i < len3) { t = t ^ gcd(arr(i + 1), arr(i + 2)); i += 1 }
  }

  def doWhileIntArrayMultiply {
    val arr2 = arr.clone
    val len = size - 1
    var i = 0
    while (i < len) {
      val value = arr2(i)
      arr2(i) = value * 2 
      i = i + 1
    }
  }

  def doTailrecOr {
    var t: Long = 0L
    val len = size - 1
    @tailrec def loop1(i: Int) {
      if (i < len) { t = t ^ or(arr(i), arr(i + 1)); loop1(i + 1) }
    }
    loop1(0)

    val len2 = size / 2
    @tailrec def loop2(i: Int) {
      if (i < len2) { t = t ^ or(arr(i + 3), arr(i + 2)); loop2(i + 1) }
    }
    loop2(0)

    val len3 = size / 3
    @tailrec def loop3(i: Int) {
      if (i < len2) { t = t ^ or(arr(i + 1), arr(i + 2)); loop3(i + 1) }
    }
    loop3(0)
  }

  def doTailrecMin {
    var t: Long = 0L
    val len = size - 1
    @tailrec def loop1(i: Int) {
      if (i < len) { t = t ^ min(arr(i), arr(i + 1)); loop1(i + 1) }
    }
    loop1(0)

    val len2 = size / 2
    @tailrec def loop2(i: Int) {
      if (i < len2) { t = t ^ min(arr(i + 3), arr(i + 2)); loop2(i + 1) }
    }
    loop2(0)

    val len3 = size / 3
    @tailrec def loop3(i: Int) {
      if (i < len2) { t = t ^ min(arr(i + 1), arr(i + 2)); loop3(i + 1) }
    }
    loop3(0)
  }

  def doTailrecGcd {
    var t: Long = 0L
    val len = size - 1
    @tailrec def loop1(i: Int) {
      if (i < len) { t = t ^ gcd(arr(i), arr(i + 1)); loop1(i + 1) }
    }
    loop1(0)

    val len2 = size / 2
    @tailrec def loop2(i: Int) {
      if (i < len2) { t = t ^ gcd(arr(i + 3), arr(i + 2)); loop2(i + 1) }
    }
    loop2(0)

    val len3 = size / 3
    @tailrec def loop3(i: Int) {
      if (i < len2) { t = t ^ gcd(arr(i + 1), arr(i + 2)); loop3(i + 1) }
    }
    loop3(0)
  }

  def doTailrecIntArrayMultiply {
    val arr2 = arr.clone
    val len = size
    @tailrec def loop(i: Int) {
      if (i < len) {
        val value = arr2(i)
        arr2(i) = value * 2
        loop(i + 1)
      }
    }
    loop(0)
  }

  
  def doForeachOr {
    var t: Long = 0L
    val len = size - 1
    (0 until len).foreach { i => t = t ^ or(arr(i), arr(i + 1)) }

    val len2 = size / 2
    (0 until len2).foreach { i => t = t ^ or(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    (0 until len3).foreach { i => t = t ^ or(arr(i + 1), arr(i + 2)) }
  }

  def doForeachMin {
    var t: Long = 0L
    val len = size - 1
    (0 until len).foreach { i => t = t ^ min(arr(i), arr(i + 1)) }

    val len2 = size / 2
    (0 until len2).foreach { i => t = t ^ min(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    (0 until len3).foreach { i => t = t ^ min(arr(i + 1), arr(i + 2)) }
  }

  def doForeachGcd {
    var t: Long = 0L
    val len = size - 1
    (0 until len).foreach { i => t = t ^ gcd(arr(i), arr(i + 1)) }

    val len2 = size / 2
    (0 until len2).foreach { i => t = t ^ gcd(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    (0 until len3).foreach { i => t = t ^ gcd(arr(i + 1), arr(i + 2)) }
  }

  def doForeachIntArrayMultiply {
    val arr2 = arr.clone
    val len = size
    (0 until len).foreach { i =>
      val value = arr2(i)
      arr2(i) = value * 2
    }
  }

  def doForOr {
    var t: Long = 0L
    val len = size - 1
    for (i <- 0 until len) { t = t ^ or(arr(i), arr(i + 1)) }

    val len2 = size / 2
    for (i <- 0 until len2) { t = t ^ or(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    for (i <- 0 until len3) { t = t ^ or(arr(i + 1), arr(i + 2)) }
  }

  def doForMin {
    var t: Long = 0L
    val len = size - 1
    for (i <- 0 until len) { t = t ^ min(arr(i), arr(i + 1)) }

    val len2 = size / 2
    for (i <- 0 until len2) { t = t ^ min(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    for (i <- 0 until len3) { t = t ^ min(arr(i + 1), arr(i + 2)) }
  }

  def doForGcd {
    var t: Long = 0L
    val len = size - 1
    for (i <- 0 until len) { t = t ^ gcd(arr(i), arr(i + 1)) }

    val len2 = size / 2
    for (i <- 0 until len2) { t = t ^ gcd(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    for (i <- 0 until len3) { t = t ^ gcd(arr(i + 1), arr(i + 2)) }
  }

  def doForIntArrayMultiply {
    val arr2 = arr.clone
    val len = size
    for (i <- 0 until len) {
      val value = arr2(i)
      arr2(i) = value * 2
    }
  }

  def doCForOr {
    var t: Long = 0L
    val len = size - 1
    cfor(0)(_ < len, _ + 1) { i => t = t ^ or(arr(i), arr(i + 1)) }

    val len2 = size / 2
    cfor(0)(_ < len2, _ + 1) { i => t = t ^ or(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    cfor(0)(_ < len3, _ + 1) { i => t = t ^ or(arr(i + 1), arr(i + 2)) }
  }

  def doCForMin {
    var t: Long = 0L
    val len = size - 1
    cfor(0)(_ < len, _ + 1) { i => t = t ^ min(arr(i), arr(i + 1)) }

    val len2 = size / 2
    cfor(0)(_ < len2, _ + 1) { i => t = t ^ min(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    cfor(0)(_ < len3, _ + 1) { i => t = t ^ min(arr(i + 1), arr(i + 2)) }
  }

  def doCForGcd {
    var t: Long = 0L
    val len = size - 1
    cfor(0)(_ < len, _ + 1) { i => t = t ^ gcd(arr(i), arr(i + 1)) }

    val len2 = size / 2
    cfor(0)(_ < len2, _ + 1) { i => t = t ^ gcd(arr(i + 3), arr(i + 2)) }

    val len3 = size / 3
    cfor(0)(_ < len3, _ + 1) { i => t = t ^ gcd(arr(i + 1), arr(i + 2)) }
  }

  def doCForIntArrayMultiply {
    val arr2 = arr.clone
    val len = size
    cfor(0)(_ < len, _ + 1) { 
      i => {
        val value = arr2(i)
        arr2(i) = value * 2
      }
    }
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy