Swift vs Java - speed at filling big array

Question

I just did a small speed comparison between Java and Swift on filling a big array. I came up with following results:

---

Swift

import Foundation

let start = CFAbsoluteTimeGetCurrent()
var intArray = Int[]()
for var i = 0; i <= 300000; ++i {
    intArray.append(0)
}
let timeTaken = CFAbsoluteTimeGetCurrent() - start
println(timeTaken)

Result: 1.66182696819305

---

Java

long start = System.currentTimeMillis();
int[] intArray;
int i = 0;
intArray = new int[300000];
for (i = 0; i < 300000; i++) {
    intArray[i]=0;
}
System.out.println("Time: "+(System.currentTimeMillis()-start)+"ms");

Result: Time: 3ms

---

This was kind of shocking me;

• is Swift 550x slower then Java.. or am I using some not-optimized code?

Answer 1

You are comparing apples and pears..

There's a fundamental difference between your two implementations.

Your java implementation will allocate memory for all 300 000 elements at once, and then set the value of each element.

The swift implementation will however potentially resize the underlying storage on every iteration since you are appending an element, not just storing it at a particular location. Most probably a resize + copy of the old storage will not happen on every iteration, but it's a possibility; and it will certainly happen more than once during your loop.

---

How would I fix it?

To fix the swift implementation you should use an array-initializer to allocate required storage directly upon creating the intArray, such as in the below example:

var intArray = Int[](count: 300000, repeatedValue: 0)
for var i = 0; i <= 300000; ++i {
    intArray[i] = 0
}

Answer 2

append resizes the array at runtime (Each loop!!), whereas your Java code creates an array of size 300000 and just sets elements in it.

resizing implies a memory copy operation, whereas in your Java code setting an index is constant time.

also, the JIT compiler may have just decided your loop is useless and optimized the whole thing away.

Answer 3

I realise that this is pretty old, but I randomly came across it while DuckDucking for something unrelated and I figured I would provide some... update.

First of all, the syntax in Swift is fairly different now from when Filip Roséen answered. There are no more C-style loops, for example. There has also been some work done on the compiler.

Just like the earlier answers explain, you are comparing two different things (growing an array versus initialising an array). However, due to the various changes, Swift is now substantially faster than it was.

Please excuse my Java code if it's suboptimal; this is pretty much the first time I've written Java.

Here's the code I used to dynamically grow an array:

Java:

import java.util.List;
import java.util.ArrayList;

public class java_GrowArray {
    public static void main(String[] args) {
        long start = System.nanoTime();

        List<Integer> intArray = new ArrayList<Integer>();

        for (int i = 0; i < 300000; i++) {
            intArray.add(0);
        }
        System.out.println("Time: "+(float)(System.nanoTime()-start)/1000000000 +" s");

    }
}

Swift:

import Foundation

let start = CFAbsoluteTimeGetCurrent()

var intArray: [Int] = []
for _ in 0..<300000 {
    intArray.append(0)
}
let timeTaken = CFAbsoluteTimeGetCurrent() - start
print("Time: \(timeTaken) s")

And here's the code for just initialising a fixed-size array:

Java:

public class java_InitialiseArray {
    public static void main(String[] args) {
        long start = System.nanoTime();
        int[] intArray;
        int i = 0;
        intArray = new int[300000];
        for (i = 0; i < 300000; i++) {
            intArray[i]=0;
        }
        System.out.println("Time: "+(float)(System.nanoTime()-start)/1000000000 +" s");

    }
}

Swift:

import Foundation

let start = CFAbsoluteTimeGetCurrent()
let intArray = [Int](repeating: 0, count: 300000)
let timeTaken = CFAbsoluteTimeGetCurrent() - start
print("Time: \(timeTaken) s")

Timings (median of five runs each):

Grow array (Java):  0.01376 s
Grow array (Swift): 0.01035 s
Init array (Java):  0.00448 s
Init array (Swift): 0.00181 s

Clearly, the performance behaviour of Swift is very different now in 2018 than it was years ago.