arrayfun可能比matlab中的显式循环慢得多。为什么？

考虑以下简单的速度测试arrayfun：

T = 4000;
N = 500;
x = randn(T, N);
Func1 = @(a) (3*a^2 + 2*a - 1);

tic
Soln1 = ones(T, N);
for t = 1:T
    for n = 1:N
        Soln1(t, n) = Func1(x(t, n));
    end
end
toc

tic
Soln2 = arrayfun(Func1, x);
toc

在我的机器上（Linux Mint 12上的Matlab 2011b），此测试的输出为：

Elapsed time is 1.020689 seconds.
Elapsed time is 9.248388 seconds.

什么？！？arrayfun，虽然公认是一种更干净的解决方案，但速度要慢一个数量级。这里发生了什么？

此外，我进行了类似的测试cellfun，发现它比显式循环慢大约3倍。同样，此结果与我预期的相反。

我的问题是：为什么是arrayfun和cellfun这么多慢？鉴于此，是否有充分的理由使用它们（除了使代码看起来更好）？

注意：我在这里谈论的是标准版本arrayfun，而不是并行处理工具箱中的GPU版本。

编辑：为了清楚起见，我知道Func1可以像Oli所指出的那样对向量进行向量化。我之所以选择它，是因为它可以针对实际问题进行简单的速度测试。

编辑：按照grungetta的建议，我用重新进行了测试feature accel off。结果是：

Elapsed time is 28.183422 seconds.
Elapsed time is 23.525251 seconds.

换句话说，似乎最大的区别在于JIT加速器在加速显式for循环方面比在其上做得更好arrayfun。这对我来说似乎很奇怪，因为它arrayfun实际上提供了更多信息，即，其使用表明调用的顺序Func1无关紧要。另外，我注意到无论JIT加速器是打开还是关闭，我的系统只使用一个CPU ...

您可以通过运行其他版本的代码来获得灵感。考虑显式写出计算，而不是在循环中使用函数

tic
Soln3 = ones(T, N);
for t = 1:T
    for n = 1:N
        Soln3(t, n) = 3*x(t, n)^2 + 2*x(t, n) - 1;
    end
end
toc

在计算机上进行计算的时间：

Soln1  1.158446 seconds.
Soln2  10.392475 seconds.
Soln3  0.239023 seconds.
Oli    0.010672 seconds.

现在，虽然完全“向量化”的解决方案显然是最快的，但是您可以看到，定义要为每个x条目调用的函数的开销很大。只需明确地写出计算，我们就能获得5倍的加速比。我猜这表明MATLAB JIT编译器不支持内联函数。根据gnovice的回答，实际上写一个正常的函数比匿名函数更好。试试吧。

下一步-移除（向量化）内部循环：

tic
Soln4 = ones(T, N);
for t = 1:T
    Soln4(t, :) = 3*x(t, :).^2 + 2*x(t, :) - 1;
end
toc

Soln4  0.053926 seconds.

另一个因素5加速：这些语句中有一些内容表明您应该避免MATLAB中的循环...还是真的？看看这个

tic
Soln5 = ones(T, N);
for n = 1:N
    Soln5(:, n) = 3*x(:, n).^2 + 2*x(:, n) - 1;
end
toc

Soln5   0.013875 seconds.

更接近“完全”矢量化版本。Matlab按列存储矩阵。您应该始终（在可能的情况下）将您的计算结构化为“按列”向量化。

现在我们可以回到Soln3。循环顺序是“行向”的。让我们改变它

tic
Soln6 = ones(T, N);
for n = 1:N
    for t = 1:T
        Soln6(t, n) = 3*x(t, n)^2 + 2*x(t, n) - 1;
    end
end
toc

Soln6  0.201661 seconds.

更好，但仍然很糟糕。单循环-好。双环-不好。我猜想MATLAB在改善循环性能方面做了不错的工作，但是循环开销仍然存在。如果您要在里面做一些较重的工作，您将不会注意到。但是由于此计算受内存带宽限制，因此您确实会看到循环开销。你会更清楚地看到调用FUNC1那里的开销。

那么arrayfun怎么了？那里也没有函数inlinig，所以开销很大。但是为什么比双嵌套循环那么糟糕呢？实际上，已经多次广泛讨论了使用cellfun / arrayfun的主题（例如here，here，here和here）。这些函数速度很慢，您不能将它们用于这种细粒度的计算。您可以将它们用于单元格和数组之间的代码简洁性和精美转换。但是该功能必须比您编写的内容重：

tic
Soln7 = arrayfun(@(a)(3*x(:,a).^2 + 2*x(:,a) - 1), 1:N, 'UniformOutput', false);
toc

Soln7  0.016786 seconds.

请注意，Soln7现在是一个单元格了。有时这很有用。现在的代码性能非常好，如果需要单元格作为输出，则在使用完全矢量化的解决方案后，无需转换矩阵。

那么为什么arrayfun比简单的循环结构慢？不幸的是，由于没有可用的源代码，我们无法确定地说。您只能猜测，由于arrayfun是通用函数，可以处理各种不同的数据结构和参数，因此在简单情况下并不一定很快，您可以将其直接表示为循环嵌套。我们不知道开销来自何处。更好的实施方案可以避免开销吗？也许不会。但是，不幸的是，我们唯一能做的就是研究性能，以确定哪些情况有效，哪些情况无效。

更新由于该测试的执行时间很短，为了获得可靠的结果，我现在在测试周围添加了一个循环：

for i=1:1000
   % compute
end

下面给出了一些时间：

Soln5   8.192912 seconds.
Soln7  13.419675 seconds.
Oli     8.089113 seconds.

您会看到arrayfun仍然很糟糕，但至少比矢量化解决方案差三个数量级。另一方面，具有按列计算的单个循环的速度与完全矢量化的速度一样快……所有操作都在单个CPU上完成。如果我切换到2个内核，则Soln5和Soln7的结果不会改变-在Soln5中，我必须使用parfor使其并行化。忘记加速... Soln7不能并行运行，因为arrayfun不能并行运行。另一方面，Olis矢量化版本：

Oli  5.508085 seconds.

那是因为！！！

x = randn(T, N); 

不是gpuarray类型；

您需要做的就是

x = randn(T, N,'gpuArray');