Я провел тестирование производительности быстрой сортировки.
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.
Так что я бы сказал, что на данный момент код Fantom работает примерно в 10 раз медленнее, чем код Java. Однако учтите, что я использовал Java int и Fantom Int, которые не совпадают. Int Java - 32-битные, а Fantom - 64-битные .
После небольшого профилирования есть признаки того, что код Fantom почти
Джава. Однако, если производительность абсолютно критическая, держитесь подальше от списков, используйте платформенные версии списков или переходите к собственному и пишите на Java.
РЕДАКТИРОВАТЬ: Я разговаривал с Брайаном, и он подтвердил мои подозрения. Причина, по которой Fantom медленнее, заключается в том, что все его Int являются 64-битными целыми числами, а все массивы Int[] аналогичны ArrayList<Long>. Новый тест покажет разницу. Причина, по которой Fantom все еще медленнее, заключается в том, что его классы Duration, Int и List имеют намного больше методов / полей, чем обычные ArrayList или Integer или System.currentMillis. Это компромисс, который может или не может вас устраивать. Если вам действительно нужна высокая производительность, просто создайте нативный метод и запрограммируйте его на Java / C # / Javascript. Таким образом, вы получите эквивалентную производительность Java.
Вот источники, если вы хотите проверить это самостоятельно:
Источник Fantom:
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)
}
}
И java с заменой всех Ints на longs и ArrayList. Оригинальная реализация Java может быть найдена в 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);
}
}