MATLAB: Converting this 3-nested for loop for parfor

for loopMATLABparallel computingParallel Computing Toolboxparfor

The context is a finite element assembly routine where I need to loop over a bunch of mesh elements. In principle, each iteration computes a small local matrix (3×3 in this case) and inserts it into the much larger global matrix according to the indices ie and je.

The iterations are completely independent of each other as I'm pretty sure as my code stands now, it could run through the outer loop in any order without any problems. But of course, this version isn't accepted by MATLAB for parfor format. Can anyone help me out here?

    NLoc = 3;
    Klocal = zeros(NLoc);
    blocal = zeros(NLoc,1);
    Aglobal = zeros(NLoc*nElem);
    bglobal = zeros(NLoc*nElem,1);
    for k=1:nElem
        kk = NLoc*(k-1);
        Klocal = function1(nElem,k);
        blocal = function2(nElem,k);
        for i=1:NLoc
            ie = i+kk;
            bglobal(ie) = bglobal(ie) + blocal(i);
            for j=1:NLoc
                je = j+kk;
                Aglobal(ie,je) = Aglobal(ie,je) + Klocal(i,j);
            end
        end
    end

Best Answer

If I'm interpreting it right, it looks like

    Aglobal = cell(nElem,1);
    bglobal = cell(nElem,1);
    parfor k=1:nElem
     Aglobal{k}=function1(nElem,k);
     bglobal{k}=function2(nElem,k);
    end
    Aglobal=blkdiag(Aglobal{:});
    bglobal=cell2mat(bglobal);

Related Solutions

MATLAB: How to modify this nested loop to work as a parfor without requiring a ridiculously large array

I think I might use SPMD for this, instead of parfor, as below.

So the first modification to make is to abandon 6-dimensional indexing i,j,k,l,m,n. Replace subscripts (i,j,k) everywhere at the top level by a linear index u and (l,m,n) by a linear index v, so that your histogram update reduces simply to

prop(horrendousfunction(u,v)) = ...
    prop(horrendousfunction(u,v)) + data(u)*data(v);

You can call ind2sub() inside horrendousfunction as needed with marginal overhead, since it's already horrendous.

The next step is to write a modified and vectorized version of horrendousfunction(). Namely you will write

   h=horrendousVectorized(U,v)

to take a vector U of linear indices u and a scalar linear index v and return the appropriate vector of h indices, i.e., h(k)=horrendousfunction(U(k),v) for all k. This should be easy if, as you say,the calculation of h just involves abs() and simple arithmetic. All of those ops are nicely vectorizable for fixed v.

Then it's all just,

    B=prod(box);
    p=zeros(N,1);
    D=distributed(data(:));
    U=distributed((1:B).');
    for v=1:B
        datav=data(v);
        spmd
            h=horrendousVectorized(U,v);
            vals=D*datav;
            p=p+accumarray(h,vals,[N,1]);
        end
    end
   spmd
    p=gplus(p,1);
   end
   prop=gather(p{1});

MATLAB: Hyperthreading question

There are several reasons why different numbers of workers can behave differently. In some situations, even if each PARFOR loop iterate takes quite a long time, it can be quicker to run fewer workers than you have cores available; other times, it can be quicker to run more workers than you have cores. This is because of the various resource contentions that your code encounters.

If your algorithm is memory bound - i.e. the main contention is for access to RAM (for example, adding together two large matrices - the amount of computation is trivial compared to the time it takes to get the data into the CPU), then you often find that fewer workers perform better.

If your algorithm is compute bound - i.e. not much memory access compared to the compuational complexity, then more workers (up to the number of physical cores) works better.

It's possible in some cases that if your algorithm is bounded by some sort of latency elsewhere, that running more workers than you have cores works best.

Best Answer

Related Solutions

MATLAB: How to modify this nested loop to work as a parfor without requiring a ridiculously large array

MATLAB: Hyperthreading question

Related Question