Java vs. Scala vs. Groovy - Performance Update

It's been quite a while since my post on the micro benchmark comparison between Java, Scala and Groovy. Since the Groovy developers tackled some performance issues with the Groovy 1.6 release, I thought, I'd give it another try. I used Groovy 1.6.3, Scala 2.7.5 and JDK 1.6.0 Update 14. I left the code that I used for the last comparison unchanged. I did not make much use of any specific language features, so it's quite a straightforward quicksort implementation, see the code below.

The Result
Before showing the result, just let me make clear, that I love the Groovy ;-) But seriously, after the anouncement, that the performance was one of the primary goals for the Groovy 1.6 release, I was a bit disappointed. We'll have to keep in mind though, that this is just a (poorly written) micro benchmark, that doesn't mean anything. And after all, it's all about the groovy language features anyway.

Nuff said, here is the result of sorting 100.000 integers:

1. Java: 45ms
2. Scala: 56ms
3. Groovy: 12800ms


And here's the code:

Java

public class QuicksortJava {

 public static void swap(int[] a, int i, int j) {
  int temp = a[i];
  a[i] = a[j];
  a[j] = temp;
 }

 public static void quicksort(int[] a, int L, int R) {
  int m = a[(L + R) / 2];
  int i = L;
  int j = R;
  while (i <= j) {
   while (a[i] < m)
    i++;
   while (a[j] > m)
    j--;
   if (i <= j) {
    swap(a, i, j);
    i++;
    j--;
   }
  }
  if (L < j)
   quicksort(a, L, j);
  if (R > i)
   quicksort(a, i, R);
 }

 public static void quicksort(int[] a) {
  quicksort(a, 0, a.length - 1);
 }

 public static void main(String[] args) {

  // Sample data
  int[] a = new int[100000];
  for (int i = 0; i < a.length; i++) {
   a[i] = i * 3 / 2 + 1;
   if (i % 3 == 0)
    a[i] = -a[i];
  }

  long t1 = System.currentTimeMillis();
  quicksort(a);
  long t2 = System.currentTimeMillis();
  System.out.println(t2 - t1);

 }

}

Scala

package quicksort

object QuicksortScala {

  def quicksort(xs: Array[Int]) {
    
    def swap(i: Int, j: Int) {
      val t = xs(i); xs(i) = xs(j); xs(j) = t
    }
    
    def sort1(l: Int, r: Int) {
      val pivot = xs((l + r) / 2)
      var i = l; 
      var j = r
      while (i <= j) {
        while (xs(i) < pivot) i += 1
        while (xs(j) > pivot) j -= 1
        if (i <= j) {
          swap(i, j)
          i += 1
          j -= 1
        }
      }
      if (l < j) sort1(l, j)
      if (r > i) sort1(i, r)
    }
    sort1(0, xs.length - 1)
  }
  
  def main(args : Array[String]) {
    var a : Array[Int] = new Array[Int](100000)
    var i : Int = 0
    for (e <- a) {
      a(i) = i*3/2+1;
   if (i%3==0) a(i) = -a(i);
      i = i+1
    }
    val t1 = System.currentTimeMillis();
    quicksort (a)
    val t2 = System.currentTimeMillis();
    println(t2-t1)
  }
}

Groovy

def swap(a, i, j) {
 temp = a[i]
 a[i] = a[j]
 a[j] = temp
}

def quicksort(a, L, R) {
 m = a[((L+R)/2).intValue()]
 i=L
 j=R
 while (i<=j) {
  while (a[i]<m) i++
  while (a[j]>m) j--
  if (i<=j) {
   swap(a, i, j)
   i++
   j--
  }
 }
 if (L<j) quicksort(a,L,j)
 if (R>i) quicksort(a,i,R)
}

def quicksort(a) {
 quicksort(a, 0, a.length-1)
}

// Sample data
a = new int[100000]
a.eachWithIndex {x, i ->
 a[i] = i*3/2+1
 if (i%3==0) a[i] = -a[i]
}

t1 = System.currentTimeMillis()
quicksort(a)
t2 = System.currentTimeMillis()
println t2-t1 

Note: There was a bug in Scala code of the first version of this post, which is now fixed. Scala now goes slightly better.