https://github.com/JuliaLang/julia/issues/9118
On Sun, Nov 23, 2014 at 10:41 AM, Amit Murthy <amit.mur...@gmail.com> wrote: > This works: > > function doparallelstuff(m = 10, n = 20) > # initialize variables > localX = Base.shmem_rand(m; pids=procs()) > localY = Base.shmem_rand(n; pids=procs()) > localf = [x->i+sum(x) for i=1:m] > localg = [x->i+sum(x) for i=1:n] > > # broadcast variables to all worker processes > @sync begin > for i in procs(localX) > remotecall(i, x->(global X; X=x; nothing), localX) > remotecall(i, x->(global Y; Y=x; nothing), localY) > remotecall(i, x->(global f; f=x; nothing), localf) > remotecall(i, x->(global g; g=x; nothing), localg) > end > end > > # compute > for iteration=1:1 > @everywhere for i=localindexes(X) > X[i] = f[i](Y) > end > @everywhere for j=localindexes(Y) > Y[j] = g[j](X) > end > end > end > > doparallelstuff() > > Though I would have expected broadcast of variables to be possible with > just > @everywhere X=localX > and so on .... > > > Looks like @everywhere does not call localize_vars. I don't know if this > is by design or just an oversight. I would have expected it to do so. Will > file an issue on github. > > > > On Sun, Nov 23, 2014 at 8:24 AM, Madeleine Udell < > madeleine.ud...@gmail.com> wrote: > >> The code block I posted before works, but throws an error when embedded >> in a function: "ERROR: X not defined" (in first line of @parallel). Why am >> I getting this error when I'm *assigning to* X? >> >> function doparallelstuff(m = 10, n = 20) >> # initialize variables >> localX = Base.shmem_rand(m) >> localY = Base.shmem_rand(n) >> localf = [x->i+sum(x) for i=1:m] >> localg = [x->i+sum(x) for i=1:n] >> >> # broadcast variables to all worker processes >> @parallel for i=workers() >> global X = localX >> global Y = localY >> global f = localf >> global g = localg >> end >> # give variables same name on master >> X,Y,f,g = localX,localY,localf,localg >> >> # compute >> for iteration=1:1 >> @everywhere for i=localindexes(X) >> X[i] = f[i](Y) >> end >> @everywhere for j=localindexes(Y) >> Y[j] = g[j](X) >> end >> end >> end >> >> doparallelstuff() >> >> On Fri, Nov 21, 2014 at 5:13 PM, Madeleine Udell < >> madeleine.ud...@gmail.com> wrote: >> >>> My experiments with parallelism also occur in focused blocks; I think >>> that's a sign that it's not yet as user friendly as it could be. >>> >>> Here's a solution to the problem I posed that's simple to use: @parallel >>> + global can be used to broadcast a variable, while @everywhere can be used >>> to do a computation on local data (ie, without resending the data). I'm not >>> sure how to do the variable renaming programmatically, though. >>> >>> # initialize variables >>> m,n = 10,20 >>> localX = Base.shmem_rand(m) >>> localY = Base.shmem_rand(n) >>> localf = [x->i+sum(x) for i=1:m] >>> localg = [x->i+sum(x) for i=1:n] >>> >>> # broadcast variables to all worker processes >>> @parallel for i=workers() >>> global X = localX >>> global Y = localY >>> global f = localf >>> global g = localg >>> end >>> # give variables same name on master >>> X,Y,f,g = localX,localY,localf,localg >>> >>> # compute >>> for iteration=1:10 >>> @everywhere for i=localindexes(X) >>> X[i] = f[i](Y) >>> end >>> @everywhere for j=localindexes(Y) >>> Y[j] = g[j](X) >>> end >>> end >>> >>> On Fri, Nov 21, 2014 at 11:14 AM, Tim Holy <tim.h...@gmail.com> wrote: >>> >>>> My experiments with parallelism tend to occur in focused blocks, and I >>>> haven't >>>> done it in quite a while. So I doubt I can help much. But in general I >>>> suspect >>>> you're encountering these problems because much of the IPC goes through >>>> thunks, and so a lot of stuff gets reclaimed when execution is done. >>>> >>>> If I were experimenting, I'd start by trying to create RemoteRef()s and >>>> put! >>>> ()ing my variables into them. Then perhaps you might be able to fetch >>>> them >>>> from other processes. Not sure that will work, but it seems to be worth >>>> a try. >>>> >>>> HTH, >>>> --Tim >>>> >>>> On Thursday, November 20, 2014 08:20:19 PM Madeleine Udell wrote: >>>> > I'm trying to use parallelism in julia for a task with a structure >>>> that I >>>> > think is quite pervasive. It looks like this: >>>> > >>>> > # broadcast lists of functions f and g to all processes so they're >>>> > available everywhere >>>> > # create shared arrays X,Y on all processes so they're available >>>> everywhere >>>> > for iteration=1:1000 >>>> > @parallel for i=1:size(X) >>>> > X[i] = f[i](Y) >>>> > end >>>> > @parallel for j=1:size(Y) >>>> > Y[j] = g[j](X) >>>> > end >>>> > end >>>> > >>>> > I'm having trouble making this work, and I'm not sure where to dig >>>> around >>>> > to find a solution. Here are the difficulties I've encountered: >>>> > >>>> > * @parallel doesn't allow me to create persistent variables on each >>>> > process; ie, the following results in an error. >>>> > >>>> > s = Base.shmem_rand(12,3) >>>> > @parallel for i=1:nprocs() m,n = size(s) end >>>> > @parallel for i=1:nprocs() println(m) end >>>> > >>>> > * @everywhere does allow me to create persistent variables on each >>>> process, >>>> > but doesn't send any data at all, including the variables I need in >>>> order >>>> > to define new variables. Eg the following is an error: s is a shared >>>> array, >>>> > but the variable (ie pointer to) s is apparently not shared. >>>> > s = Base.shmem_rand(12,3) >>>> > @everywhere m,n = size(s) >>>> > >>>> > Here are the kinds of questions I'd like to see protocode for: >>>> > * How can I broadcast a variable so that it is available and >>>> persistent on >>>> > every process? >>>> > * How can I create a reference to the same shared array "s" that is >>>> > accessible from every process? >>>> > * How can I send a command to be performed in parallel, specifying >>>> which >>>> > variables should be sent to the relevant processes and which should be >>>> > looked up in the local namespace? >>>> > >>>> > Note that everything I ask above is not specific to shared arrays; >>>> the same >>>> > constructs would also be extremely useful in the distributed case. >>>> > >>>> > ---------------------- >>>> > >>>> > An interesting partial solution is the following: >>>> > funcs! = Function[x->x[:] = x+k for k=1:3] >>>> > d = drand(3,12) >>>> > let funcs! = funcs! >>>> > @sync @parallel for k in 1:3 >>>> > funcs) >>>> > end >>>> > end >>>> > >>>> > Here, I'm not sure why the let statement is necessary to send funcs!, >>>> since >>>> > d is sent automatically. >>>> > >>>> > --------------------- >>>> > >>>> > Thanks! >>>> > Madeleine >>>> >>>> >>> >>> >>> -- >>> Madeleine Udell >>> PhD Candidate in Computational and Mathematical Engineering >>> Stanford University >>> www.stanford.edu/~udell >>> >> >> >> >> -- >> Madeleine Udell >> PhD Candidate in Computational and Mathematical Engineering >> Stanford University >> www.stanford.edu/~udell >> > >
