问题标签 [loop-unrolling]

在gcc 4.4.6文档中指出：

我正在编译这段代码：

...一次有funroll-all-loops优化，一次没有：

然后我diff用来比较每个的汇编代码（使用生成-S -fverbose-asm）。

生成的代码是相同的。

尝试将循环更改为 a do while; 调整循环计数器（最多 100 个）；更改循环体内的语句。

我会错过什么？为什么这个循环没有展开？

更新

Nikos C--param max-unroll-times=N建议使用其中 N 是上限来提高循环注册参数。虽然这是一个明智的建议，但它并没有改变行为。我还将循环迭代降低到只有 10 次。还更新了代码以实际“做”某事，没有任何变化。

我正在尝试评估 AMD 和 Nvidia GPU 的 OpenCL 之间的性能差异。我有一个执行矩阵向量乘法的内核。我现在在两个不同的系统上运行内核，我的笔记本电脑有一个带有 Ubuntu 12.04 和 CUDA 4.0（包含 OpenCL 库和头文件）的 NVidia GT525m，另一个是带有 AMD Radeon HD7970 的台式机，再次带有 Ubuntu 12.04 和最新的 Catalyst 驱动程序。

在内核中，我有两条#pragma unroll语句为 Nvidia OpenCL 实现（~6x）产生了很大的加速。但是 AMD OpenCL 版本不会产生任何加速。使用 AMD APP 内核分析器查看内核会出现未使用展开的错误，因为行程计数未知。所以我的问题是，是否#pragma unroll可以与 AMD OpenCL 一起使用，或者是否有替代方案（也许是我不知道的编译器标志）。我在下面包含了内核

这个相同的内核在两种实现中都产生了正确的结果，但是 #pragma unroll 命令对 AMD 没有任何作用（通过将它们注释掉来检查）。

我有一个像这样的立方 3D 数组“类”：

我想推广到多个维度，但不影响访问性能。这是我的简单方法：

有什么方法可以“展开”我的makeIndex函数，以便在声明时对循环进行一次评估，而不是在调用时？使用运行时生成的代码的开销是否会eval抵消new Function()不循环的好处？

两者size和N本质上都是常数，因此重复的乘法和迭代感觉就像只能完成一次。

我有一些看起来像这样的代码：

简而言之，我有一个维度为 54 的数组 premultz。我有一个维度为 501 的数组 sinphi。我想将 sinphi 的第一个值乘以 premultz 的所有条目，并将其存储在 arg1 的前 54 个条目中，然后sinphi 的第二个值乘以 premultz 的所有条目并将其存储在 arg1 的 second54 个条目中，依此类推。

这些是扁平矩阵。为了速度，我将它们展平，因为这个项目的主要目标之一是非常快的代码。

我的问题是：在 Fortran90 中编码这种计算是否有更有效的方法？我知道 Fortran 有很多漂亮的数组操作可以完成，但我并不完全了解。

提前致谢。

试图优化fun_a1()功能。变量j在范围内不变fun_a1()。因此，为每个“i”迭代检查 j==1 或 2 或 3 显然是对 CPU 周期的浪费。但是如果我试图将条件评估带到循环之外，我必须为每个条件编写冗余循环。在 C 语言中，我可以通过使用函数指针轻松解决这个问题。但是，C++ 不允许指向非静态函数的指针。我发现了一些描述神秘的“指向成员”的链接。（示例 1，示例 2）但是仍然不清楚如何从对象本身内部使用它，例如从 fun_a() 内部？还是可以通过其他方式进行优化？

我有一个带有 a 的内核，#pragma unroll 80我正在使用 NVIDIA GT 285、计算能力 1.3、网格架构运行它：dim3 thread_block( 16, 16 )并且dim3 grid( 40 , 30 )它运行良好。

当我尝试使用 NVIDIA GT 580、计算能力 2.0 和上述网格架构运行它时，它运行良好。

当我将 GT 580 上的网格架构更改为

dim3 thread_block( 32 , 32 )并且dim3 grid( 20 , 15 )，因此产生与上述相同数量的线程，我得到不正确的结果。

如果我在 GT 580 中删除#pragma unroll 80或替换它，它工作正常。#pragma unroll 1如果我不这样做，那么内核就会崩溃。

有谁知道为什么会这样？先感谢您

编辑：检查两个设备上的内核错误，我得到“无效参数”。当我搜索此错误的原因时，我发现当网格和块的尺寸超出其限制时会发生这种情况。但对我来说情况并非如此，因为我每个块使用 16x16=256 个线程和 40x30=1200 个总块。据我所知，这些值位于 GPU 网格的边界内，计算能力为 1.3。我想知道这是否与我遇到的循环展开问题有关。

我有以下循环，我在 ARM 处理器上运行。

通过循环的缓慢性能，我可以判断编译器无法展开这个循环，因为当我手动展开时，它变得非常快。我认为编译器被pin指针弄糊涂了。我们可以在这里使用restrict关键字来帮助编译器，还是restrict只为函数参数保留？一般来说，我们如何告诉编译器展开它而不用担心pin指针。

我试图告诉我的编译器使用#pragma unroll. 但是，迭代次数由编译时变量决定，因此循环需要展开那么多次。像这样：

但是，编译器不喜欢这样，因为它给了我以下警告warning: extra characters in the unroll pragma (expected a single positive integer), ignoring pragma for this loop：我当然理解这意味着什么：它需要一个整数而不是表达式。但是，有没有办法做到这一点，而无需每次更改时都更改 unroll 参数ITEMS？

我使用的编译器是 CUDA 的 NVCC 编译器。

I am working on a large application for which I need to perform loop unrolling on subsequent dependent loops for a certain procedure. I have written below a small sample piece of code to replicate the larger version.

Consider the original code:

Now I am unrolling the loop i by a factor of 2:

Now I wish to unroll the loop i and j by a factor of 2, but since loop j depends on loop i, I am a bit unsure as to how I should approach writing it. How can I rewrite the code to unroll both i and j by a factor of 2. Also the code will become increasingly clumsier as i increase the unroll factor. Is there a clever way to unroll it manually, without the code becoming too ugly.

I cannot use compiler flags (example:-funroll-loops) in this particular case. I want approach it by manual loop unrolling.

Thank you for your time.

这部分代码来自我的一个向量类的点积方法。该方法对目标向量数组（1000 个向量）进行内积计算。

当向量长度为​​奇数（262145）时，计算时间为 4.37 秒。当向量长度（N）为 262144（8 的倍数）时，计算时间为 1.93 秒。

问题：将时间从 4.37 秒减少到 1.93 秒（快 2 倍）是 JIT 使用 SIMD 指令的明智决定还是我的循环展开的积极影响？

如果 JIT 不能自动进行 SIMD 优化，那么在这个例子中也没有 JIT 自动进行展开优化，这是真的吗？

对于 1M 次迭代（向量）和 64 的向量大小，加速乘数达到 3.5 倍（缓存优势？）。

谢谢。