Could you provide the updated code in a github repo than separate files in
a gist? Much easier to just clone it and run with the latest changes. The
gist still has the Dicts.
-viral
On Sunday, September 20, 2015 at 12:00:15 PM UTC+5:30, Adam wrote:
>
> Thanks for the comments! Based on both your comments, I've made the
> following changes:
>
> 1. I eliminated the dictionary structure (I only did this as a matter
> of organization). There are no longer any dictionaries, and those
> "parameters" and "distributions" are all now passed directly as function
> arguments.
> 2. I eliminated the type declarations from my function arguments
> (since there are no longer any dictionaries).
> 3. I surrounded the majority of the code with a "run_sim()" function.
> Now, it looks like this:
>
> include("dist_o_i.jl")
> include("calc_net.jl")
> include("update_w.jl")
> include("set_up_sim.jl")
> include("simulation.jl")
>
> function run_sim( )
> include("set_up.jl")
> v1 = [-3 0.5 0.5]
>
> term_condition = false
> iter = 0
>
> while !term_condition
>
> v2 = [-1.5 0 1.5 0]
>
> s_array, w_array, b_array = simulation( v1, v2, D, T, I_val, max_b,
> w_max, gamma_val, controls, Prob_o, signals )
>
> iter = iter + 1
>
> if iter >= 1
> term_condition = true
> end
>
> end
> end
>
> @time run_sim()
>
>
> Unfortunately, these adjustments have not changed the performance. Running
> twice, I got:
>
> elapsed time: 39.365116756 seconds (20316825420 bytes allocated, 37.92% gc
> time)
> elapsed time: 39.856962087 seconds (20239718784 bytes allocated, 38.50% gc
> time)
>
> Spencer: Re: your point about running "simulation.jl" before timing
> it...yes. That's the reason I provided multiple "elapsed time" results, to
> show that I'm running the function a few times and getting the same
> performance. With my latest alterations, I'm running "@time run_sim()"
> multiple times, and seeing (roughly) the same performance each time.
>
> Any other ideas? Is there something about the matrix or vector
> multiplication that could be slowing it down? Maybe it has to do with the
> arrays in which I'm storing the data?
>
>
>
> On Saturday, September 19, 2015 at 1:18:54 PM UTC-5, Spencer Russell wrote:
>>
>> Hi Adam,
>>
>> Welome to Julia!
>>
>> Just to check - are you calling your `simulation(…)` function before you
>> time it? Otherwise your timing will include the time it takes to compile
>> the function, which happens the first time it’s called with a given set of
>> argument types.
>>
>> Your `param` dict is of type (Any, Any), which means that the compiler
>> doesn’t know anything about the type of objects inside it. You’re doing a
>> lot of access into the dict in your inner loops, which causes similar
>> issues to accessing global variables. It will probably speed things up if
>> you declare it at `params{String, Float64}()` instead (or whatever the type
>> of the parameters is), or give the parameters as arguments to your
>> simulation function (probably best).
>>
>> -s
>>
>> On Sep 19, 2015, at 12:44 PM, Adam <[email protected]> wrote:
>>
>> Hi, I'm a novice to Julia but have heard promising things and wanted to
>> see if the language can help with a problem I'm working on. I have some
>> Matlab code with some user-defined functions that runs a simulation in
>> about ~1.4 seconds in Matlab (for a certain set of parameters that
>> characterize a small problem instance). I translated the code into Julia,
>> and to my surprise the Julia code runs 5x to 30x slower than the Matlab
>> code. I'll be running this code on much larger problem instances many, many
>> times (within some other loops), so performance is important here.
>>
>> I created a GitHub gist that contains a stripped-down version of the
>> Julia code that gets as close to (as I can find) the culprit of the
>> problem. The gist is here:
>> https://gist.github.com/anonymous/010bcbda091381b0de9e. A quick
>> description:
>>
>> - set_up.jl sets up parameters and other items.
>> - set_up_sim.jl sets up items particular to the simulation.
>> - simulation.jl runs the simulation.
>> - calc_net.jl, dist_o_i.jl, and update_w.jl are user-defined
>> functions executed in the simulation.
>>
>>
>> On my laptop (running in Juno with Julia version 0.3.10), this code
>> yields:
>> elapsed time: 43.269609577 seconds (20297989440 bytes allocated, 38.77%
>> gc time)
>> elapsed time: 38.500054653 seconds (20291872804 bytes allocated, 40.41%
>> gc time)
>> elapsed time: 40.238907235 seconds (20291869252 bytes allocated, 39.44%
>> gc time)
>>
>> Why is so much memory used, and why is so much time spent in garbage
>> collection?
>>
>> I'm familiar with
>> http://docs.julialang.org/en/release-0.3/manual/performance-tips/ and
>> have tried to follow these tips to the best of my knowledge. One example of
>> what might be seen as low-hanging fruit: I tried removing the type
>> declarations from my functions, but this actually increased the run-time of
>> the code by a few seconds. Also, other permutations of the column orders
>> pertaining to D, T, and I led to slower performance.
>>
>> I'm sure there are several issues at play here-- I'm just using Julia for
>> the first time. Any tips would be greatly appreciated.
>>
>>
>>
