ChrisRackauckas
commented
7 years ago The way that you have this code, you are running the full simulation twice, and it will pmap it to 4 processes, and overload two. Instead you should just do sol = boser(Ntraj). That solve command for Monte Carlo problems has parallelism inside of it, so you don't want to @everywhere the call to it. Instead, you want the master process to initiate it, and then let the works do it.
Also, the number of processes is the number of worker processes. So for a dual core machine, you want at least 2 cores. But, the idea that the number of processes should match the number of cores is a myth propagated by people who don't really understand modern computing. In reality, for most algorithms you probably want more. This is because there's lags in there where extra processes can compute, while other processes are managing memory buses. In reality, you can check that you usually want more. This blog post I wrote is about almost the same problem:
http://www.stochasticlifestyle.com/236-2/
So the actual code should be something like:
addprocs(2) # Probably more is better, need to benchmark
@everywhere using DifferentialEquations
@everywhere f = @ode_def_bare Drift begin
dα₁ = -(γ + 2*im*χ*α₁*ᾱ₁)α₁ + im*J*α₂
dᾱ₁ = -(γ - 2*im*χ*ᾱ₁*α₁)ᾱ₁ - im*J*ᾱ₂
dα₂ = ϵ - 2*im*χ*α₂^2*ᾱ₂ + im*J*(α₁ + α₃)
dᾱ₂ = conj(ϵ) + 2*im*χ*ᾱ₂^2*α₂ - im*J*(ᾱ₁ + ᾱ₃)
dα₃ = -(γ + 2*im*χ*α₃*ᾱ₃)α₃ + im*J*α₂
dᾱ₃ = -(γ - 2*im*χ*ᾱ₃*α₃)ᾱ₃ - im*J*ᾱ₂
end γ=>1. χ=>.001 ϵ=>10. J=1.
@everywhere g = @ode_def_bare Diffusion begin
dα₁ = sqrt(-2*im*χ*α₁^2)
dᾱ₁ = sqrt(-2*im*χ*ᾱ₁^2)
dα₂ = sqrt(-2*im*χ*α₂^2)
dᾱ₂ = sqrt(-2*im*χ*ᾱ₂^2)
dα₃ = sqrt(-2*im*χ*α₃^2)
dᾱ₃ = sqrt(-2*im*χ*ᾱ₃^2)
end χ=>.001
@everywhere @inline function my_noise_function!(rand_vec,integrator)
for i in eachindex(rand_vec)
rand_vec[i] = randn()
end
end
@everywhere my_noise = NoiseProcess{:White,true,typeof(my_noise_function!)}(my_noise_function!)
@everywhere function boser(Ntraj::Int64)
ti = 0.
tf = 20.
Nt = 100
tspan = (ti,tf)
t = collect(linspace(ti,tf,Nt))
N0 = 40
a0 = sqrt(N0/2)*(randn(6)+im*randn(6))
a0[2] = conj(a0[1]);a0[4]=conj(a0[3]);a0[6]=conj(a0[5]);
prob = SDEProblem(f,g,a0,tspan,noise=my_noise)
#alg = EM()
alg = EulerHeun()
dt = 1/100
monte_prob = MonteCarloProblem(prob) #,prob_func=prob_func)
return solve(monte_prob,alg,dt=dt,saveat=t,save_everystep=false,dense=false,num_monte=Ntraj)
end
@time @everywhere boser(1) # precompile everywhere
@time boser(1)
Ntraj = 1000
@time sol = boser(Ntraj)
AshtonSBradley
I want to run this code on local machine (dual core), and make sure I am getting proper parallel speedup before deploying on small cluster. Am seeing some interesting timing behaviour and want to know best strategy for parallelism here. The @everywhere is trying to make it parallel. Some timing comments are at the end:
(error it what I posted initially: @everywhere not used in final
sol = ...call, timings unchanged)