Question

问题是我在那里工作有这样一部分代码，如下所示。定义部分只是为了向您展示数组的大小。下面我贴了矢量化版本 - 它慢了2倍。为什么会这样？我知道如果向量化需要大的临时变量，我会发生这种情况，但（似乎）在这里不是真的。

通常情况下，我可以做些什么（除了parfor，我已经使用过）来加速这段代码？

maxN = 100;  
levels = maxN+1;  
xElements = 101;  
umn = complex(zeros(levels, levels));  
umn2 = umn;  
bessels = ones(xElements, xElements, levels);    % 1.09 GB  
posMcontainer = ones(xElements, xElements, maxN);  

tic  
for j = 1 : xElements  
    for i = 1 : xElements  
        for n = 1 : 2 : maxN  
            nn = n + 1;  
            mm = 1;  
            for m = 1 : 2 : n  
                umn(nn, mm) = bessels(i, j, nn) * posMcontainer(i, j, m);  
                mm = mm + 1;  
            end  
        end  
    end  
end  
toc % 0.520594 seconds  


tic  
for j = 1 : xElements  
    for i = 1 : xElements  
        for n = 1 : 2 : maxN  
            nn = n + 1;  
            m = 1:2:n;  
            numOfEl = ceil(n/2);  
            umn2(nn, 1:numOfEl) = bessels(i, j, nn) * posMcontainer(i, j, m);  
        end  
    end  
end  
toc % 1.275926 seconds  

sum(sum(umn-umn2)) % veryfying, if all done right

最好的问候，
亚历

来自探查者：

from Profiler

修改

在回复@Jason answer时，此替代方案需要相同的时间：

for n = 1:2:maxN  
    nn(n) = n + 1;  
    numOfEl(n) = ceil(n/2);  
end  

for j = 1 : xElements  
    for i = 1 : xElements  
        for n = 1 : 2 : maxN  
            umn2(nn(n), 1:numOfEl(n)) = bessels(i, j, nn(n)) * posMcontainer(i, j, 1:2:n);  
        end  
    end  
end

EDIT2 ：
回复@EBH：
关键是要做到以下几点：

parfor i = 1 : xElements  
    for j = 1 : xElements  
    umn = complex(zeros(levels, levels)); % cleaning  
    for n = 0:maxN
        mm = 1;
        for m = -n:2:n
            nn = n + 1; % for indexing

            if m < 0
                umn(nn, mm) = bessels(i, j, nn) * negMcontainer(i, j, abs(m));
            end

            if m > 0
                umn(nn, mm) = bessels(i, j, nn) * posMcontainer(i, j, m);
            end

            if m == 0
                umn(nn, mm) = bessels(i, j, nn);
            end

            mm = mm + 1; % for indexing
        end % m
    end % n
    beta1 = sum(sum(Aj1.*umn));
    betaSumSq1(i, j) = abs(beta1).^2;

    beta2 = sum(sum(Aj2.*umn));
    betaSumSq2(i, j) = abs(beta2).^2;
    end % j
end % i

我尽可能地加快了速度。您所写的内容仅包含最后bessels和posMcontainer值，因此不会产生相同的结果。在实际代码中，这两个容器的填充不是1，而是有一些预先计算的值。

Answer 1

编辑完成后，我可以看到umn只是另一个计算的临时变量。它仍然可以主要是可矢量化的：

betaSumSq1 = zeros(xElements); % preallocating
betaSumSq2 = zeros(xElements); % preallocating
% an index matrix to fetch the right values from negMcontainer and
% posMcontainer:
indmat = tril(repmat([0 1;1 0],ceil((maxN+1)/2),floor(levels/2)));
indmat(end,:) = [];
% an index matrix to fetch the values in correct order for umn:
b_ind = repmat([1;0],ceil((maxN+1)/2),1);
b_ind(end) = [];
tempind = logical([fliplr(indmat) b_ind indmat+triu(ones(size(indmat)))]);

% permute the arrays to prevent squeeze:
PM = permute(posMcontainer,[3 1 2]);
NM = permute(negMcontainer,[3 1 2]);
B = permute(bessels,[3 1 2]);

for k = 1 : maxN+1 % third dim
    for jj = 1 : xElements % columns
        b = B(:,jj,k); % get one vector of B

        % perform b*NM for every row of NM*indmat, than flip the result:
        neg = fliplr(bsxfun(@times,bsxfun(@times,indmat,NM(:,jj,k).'),b));

        % perform b*PM for every row of PM*indmat:
        pos = bsxfun(@times,bsxfun(@times,indmat,PM(:,jj,k).'),b);

        temp = [neg mod(1:levels,2).'.*b pos].'; % concat neg and pos
        % assign them to the right place in umn:
        umn = reshape(temp(tempind.'),[levels levels]).';

        beta1 = Aj1.*umn;
        betaSumSq1(jj,k) = abs(sum(beta1(:))).^2;
        beta2 = Aj2.*umn;
        betaSumSq2(jj,k) = abs(sum(beta2(:))).^2;
    end
end

这样可以将运行时间从 ~95 秒减少到 3 秒（两者都没有parfor），因此几乎 97％< /强>

Answer 2

我怀疑是内存分配。您正在以3深度循环重新分配m数组。尝试重新安排代码：

tic
for n = 1 : 2 : maxN
    nn = n + 1;
    m = 1:2:n;
    numOfEl = ceil(n/2);
    for j = 1 : xElements
        for i = 1 : xElements
            umn2(nn, 1:numOfEl) = bessels(i, j, nn) * posMcontainer(i, j, m);
        end
    end
end
toc % 1.275926 seconds

我在Igor pro中尝试这个，这是一种类似的语言，但有不同的优化。因此，直接翻译的时间与Matlab相同（在Igor中矢量化的速度稍快）。但重新排序循环确实加快了矢量化形式。

在代码的第二部分中，即设置umn2，在循环中，您有：

nn = n + 1;  
m = 1:2:n;  
numOfEl = ceil(n/2);

这3行不需要来自i和j循环的任何输入，它们只使用n循环。因此，重新排序循环使i和j位于n循环内将意味着这3行的次数减少xElements^2次（100 ^ 2）次。我怀疑是m = 1:2:n行需要时间，因为那是分配一个数组。

矢量化代码比循环慢？ MATLAB

2 个答案: