Added benchmarks with results for equality.

3 files changed, 122 insertions, 0 deletions

diff --git a/test/files/bench/equality/eq.scala b/test/files/bench/equality/eq.scala
new file mode 100755
index 0000000000..8ac5b5ef5c
--- /dev/null
+++ b/test/files/bench/equality/eq.scala
@@ -0,0 +1,34 @@
+object eq extends testing.Benchmark {
+
+  def eqtest[T](creator: Int => T, n: Int): Int = {
+    val elems = Array.tabulate[AnyRef](n)(i => creator(i % 2).asInstanceOf[AnyRef])
+
+    var sum = 0
+    var i = 0
+    while (i < n) {
+      var j = 0
+      while (j < n) {
+        if (elems(i) eq elems(j)) sum += 1
+        j += 1
+      }
+      i += 1
+    }
+    sum
+  }
+
+  val obj1 = new Object
+  val obj2 = new Object
+
+  def run() {
+    var sum = 0
+    sum += eqtest(x => if (x == 0) obj1 else obj2, 2000)
+    sum += eqtest(x => x, 1000)
+    sum += eqtest(x => x.toChar, 550)
+    sum += eqtest(x => x.toByte, 550)
+    sum += eqtest(x => x.toLong, 550)
+    sum += eqtest(x => x.toShort, 100)
+    sum += eqtest(x => x.toFloat, 100)
+    sum += eqtest(x => x.toDouble, 100)
+    assert(sum == 2958950)
+  }
+}
diff --git a/test/files/bench/equality/eqeq.log b/test/files/bench/equality/eqeq.log
new file mode 100755
index 0000000000..d1e27aceed
--- /dev/null
+++ b/test/files/bench/equality/eqeq.log
@@ -0,0 +1,42 @@
+Banchmark results for testing equality operations:

+eq.scala: Base case, use eq equality only

+eqeq.scala: Test case, use == instead of eq.

+All tests run on Thinkpad T400, 1.6.0_12 client VM.

+Test command: java eq 5 5

+              java eqeq 5 5

+eq.scala, no -optimise

+eq$		109		78		79		63		63

+eq$		94		63		63		78		78

+eq$		94		62		62		62		78

+eq$		94		78		78		78		78

+eq$		94		78		78		78		78

+eq.scala, with -optimise

+eq$		421		63		62		47		63

+eq$		406		62		62		63		62

+eq$		407		62		62		78		63

+eq$		406		63		63		62		62

+eq$		407		62		62		63		47

+eqeq.scala with version of BoxesRuntime as of Nov 13th, no -optimise

+eqeq$		562		516		516		516		515

+eqeq$		547		515		515		531		532

+eqeq$		532		516		516		515		516

+eqeq$		547		531		531		516		531

+eqeq$		547		515		515		516		516

+eqeq.scala with version of BoxesRuntime as of Nov 13th, with -optimise

+eqeq$		1031		390		391		391		391

+eqeq$		1031		391		391		391		390

+eqeq$		1031		390		390		391		391

+eqeq$		1031		406		407		391		390

+eqeq$		1031		390		390		391		391

+eqeq.scala with 1st optimized of Nov 14th, no -optimise

+eqeq$		484		421		438		438		437

+eqeq$		484		438		437		437		438

+eqeq$		469		437		453		454		438

+eqeq$		468		437		438		468		438

+eqeq$		485		437		437		422		438

+eqeq.scala with 1st optimized of Nov 14th, with -optimise

+eqeq$		1016		375		391		375		375

+eqeq$		1016		375		391		390		375

+eqeq$		1016		390		391		375		375

+eqeq$		1015		375		391		390		375

+eqeq$		1016		390		375		375		375

diff --git a/test/files/bench/equality/eqeq.scala b/test/files/bench/equality/eqeq.scala
new file mode 100755
index 0000000000..afccece88a
--- /dev/null
+++ b/test/files/bench/equality/eqeq.scala
@@ -0,0 +1,46 @@
+/** benchmark for testing equality.
+ *  Mix: == between non-numbers ith Object.equals as equality: 66%
+ *          50% of these are tests where eq is true.
+ *       == between boxed integers: 17%
+ *       == between boxed characters: 5%
+ *       == between boxed bytes: 5%
+ *       == between boxed longs: 5%
+ *       == between boxed shorts: < 1%
+ *       == between boxed floats: < 1%
+ *       == between boxed doubles: < 1%
+ * In all cases 50% of the tests return true.
+ */
+object eqeq extends testing.Benchmark {
+
+  def eqeqtest[T](creator: Int => T, n: Int): Int = {
+    val elems = Array.tabulate[AnyRef](n)(i => creator(i % 2).asInstanceOf[AnyRef])
+
+    var sum = 0
+    var i = 0
+    while (i < n) {
+      var j = 0
+      while (j < n) {
+        if (elems(i) == elems(j)) sum += 1
+        j += 1
+      }
+      i += 1
+    }
+    sum
+  }
+
+  val obj1 = new Object
+  val obj2 = new Object
+
+  def run() {
+    var sum = 0
+    sum += eqeqtest(x => if (x == 0) obj1 else obj2, 2000)
+    sum += eqeqtest(x => x, 1000)
+    sum += eqeqtest(x => x.toChar, 550)
+    sum += eqeqtest(x => x.toByte, 550)
+    sum += eqeqtest(x => x.toLong, 550)
+    sum += eqeqtest(x => x.toShort, 100)
+    sum += eqeqtest(x => x.toFloat, 100)
+    sum += eqeqtest(x => x.toDouble, 100)
+    assert(sum == 2968750)
+  }
+}