is fantom generated bytecode as performant as java equivalent bytecode?
-
22-10-2019 - |
Question
from the many jvm languages appearing nowdays, there's one that seems to be particularly appealing
have a look at
http://fantom.org/doc/docIntro/Tour.html
I just wonder if, when ignoring the dynamic typing feature, the generated bytecode is performant equivalent to java...
ps: added aclaration about performance
Solution
I did some quicksort performance testing.
Int[100.000] array quicksort
Java ~ 11ms
Java using long and ArrayList<Long> ~ 66ms
Fantom ~ 97 ms
Int[1.000.000] array quicksort
Java ~ 91ms
Java using long and ArrayList<long> ~ 815ms
Fantom ~ 1100ms.
So I'd say that at the moment Fantom's code runs about 10x slower than Java's code. However do note that I used Java's int and Fantom's Int which aren't the same. Java's int are 32-bit and Fantom's are 64-bit.
After profiling things a bit there are indications that Fantom code is almost performant as Java. However if performance is absolutely critical, stay away from Lists, use platform specific versions of lists or drop down to native and write in Java.
EDIT: I had a talk with brian and he confirmed my suspicions. The reason Fantom is slower is because all it's Int
are 64-bit integer and all Int[]
arrays are similar to ArrayList<Long>
. The new test show the difference. The reason Fantom is still slower is probably that its Duration, Int and List classes have a lot more methods/fields than plain ArrayList
or Integer
or System.currentMillis
. It's a tradeoff that may or may not suit you. If you really need high performance just make a native method and program it in Java/C#/Javascript. That way you'll get Java equivalent performance.
Here are sources if you want to test it yourself:
Fantom source:
class TestQuickSort
{
public static Void swap(Int[] a, Int i, Int j) {
temp := a[i];
a[i] = a[j];
a[j] = temp;
}
public static Void quicksortA(Int[] a, Int L, Int R) {
m := a[(L + R) / 2];
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)
quicksortA(a, L, j);
if (R > i)
quicksortA(a, i, R);
}
public static Void quicksort(Int[] a) {
quicksortA(a, 0, a.size - 1);
}
static Void main(Str[] args) {
// Sample data
a := Int[,]
for(i := 0; i<1000000; i++)
{
a.add(i*3/2+1)
if(i%3==0) {a[i]=-a[i]}
}
t1 := Duration.now
quicksort(a);
t2 := Duration.now
echo((t2-t1).toMillis)
}
}
And java with all the Ints replaced by longs and ArrayList. Original Java implementation can be found at http://stronglytypedblog.blogspot.com/2009/07/java-vs-scala-vs-groovy-performance.html.
import java.util.ArrayList;
public class QuicksortJava {
public static void swap(ArrayList<Long> a, long i, long j) {
long temp = a.get((int)i);
a.set((int)i, a.get((int)j));
a.set((int)j, temp);
}
public static void quicksort(ArrayList<Long> a, long L, long R) {
long m = a.get((int)(L + R) / 2);
long i = L;
long j = R;
while (i <= j) {
while (a.get((int)i) < m)
i++;
while (a.get((int)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(ArrayList<Long> a) {
quicksort(a, 0, a.size() - 1);
}
public static void main(String[] args) {
// Sample data
long size = 100000;
ArrayList<Long> a = new ArrayList<Long>((int)size);
for (long i = 0; i < size; i++) {
a.add(i * 3 / 2 + 1);
if (i % 3 == 0)
a.set((int)i, -a.get((int)i));
}
long t1 = System.currentTimeMillis();
quicksort(a);
long t2 = System.currentTimeMillis();
System.out.println(t2 - t1);
}
}
OTHER TIPS
I have no experience with fantom, but it looks like the fantom interpreter can use java, .net or JS libraries, but it's not that the fantom compiled bytecode can be read out of the box by java, .net or javascript.
Having said that... I'll check it later, it looks interesting :)
Fantom compiles down to its own byte-code format called "fcode" - which is then translated to java byte code or IL at runtime - see this page for more details:
http://fantom.org/doc/docLang/Deployment.html
JavaScript works a bit different - actual JavaScript source code is produced at compile time from the Fantom source code (along with all the meta-data the Fantom runtime needs) - to produce a standalone js file you can run directly in your browser.