I have followed the Julia project for a while now, and I have some comments to the code that might be relevant.
- It seems like you run a substantial amount of the code in global scope. The global environment is currently very slow in Julia, because the types all variables have to be checked on every iteration. Loops should usually be written in a function.
- You seem to use array slicing. Currently that makes a copy because Julia does not have fast Array views. You might try to switch them for subarray, but they are currently much slower than they should.
The loading time of PyPlot (and any other package) is a known issue, and is because parsing and compiling Julia code to machine code, is time consuming. There are ideas about having a cache for this process so that this process becomes instantaneous, but it is not finished yet. The Base library is currently cached in compiled state, so most of the infrastructure is on the master branch now.
ADDED:
I tried to run the test in an isolated function and got these results. See this gist
Parsing:
elapsed time: 0.334042578 seconds (11797548 bytes allocated)
And tree consecutive runes of the main test loop.
elapsed time: 0.62999287 seconds (195210884 bytes allocated)
elapsed time: 0.39398753 seconds (184735016 bytes allocated)
elapsed time: 0.392036875 seconds (184735016 bytes allocated)
Notice how the timing improved after the first run, because the compiled code was used again.
Update 2
With some improved memory handling (ensure reuse of arrays, because assignment does not copy), I got the timing down to 0.2 seconds (on my machine). There is definitely more that could be done to avoid allocating new arrays, but then it starts to be a little tricky.
This line does not do what you think:
vx_old = vx
but this do what you want:
copy!(vx_old, vx)
and devectorize one loop.
x += 0.5*(vx + vx_old)*delta_t
y += 0.5*(vy + vy_old)*delta_t
to:
for i = 1:nvortex
x[i] += 0.5*(vx[i] + vx_old[i])*delta_t
y[i] += 0.5*(vy[i] + vy_old[i])*delta_t
end