使用指针的for循环优化

Question

我正在尝试优化代码以在 7 秒内运行。我把它降到了 8，现在我正在尝试使用指针来加速代码。但是当我尝试编译时 gcc 给出了一个错误：

.c:29: 警告：来自不兼容指针类型的赋值 .c:29: 警告：不同指针类型的比较缺少强制转换

这是我在尝试使用指针之前所拥有的：

#include <stdio.h>
#include <stdlib.h>

#define N_TIMES     600000
#define ARRAY_SIZE   10000

int main (void)
{
    double  *array = calloc(ARRAY_SIZE, sizeof(double));
    double  sum = 0;
    int     i;

    double sum1 = 0;

    for (i = 0; i < N_TIMES; i++) {

        int     j;

        for (j = 0; j < ARRAY_SIZE; j += 20) {
            sum += array[j] + array[j+1] + array[j+2] + array[j+3] + array[j+4] + array[j+5] + array[j+6] + array[j+7] + array[j+8] + array[j+9];
            sum1 += array[j+10] + array[j+11] + array[j+12] + array[j+13] + array[j+14] + array[j+15] + array[j+16] + array[j+17] + array[j+18] + array[j+19];
            }

        }

    sum += sum1;

    return 0;
}

这是我使用指针时的结果（此代码会产生错误）：

int     *j;

        for (j = array; j < &array[ARRAY_SIZE]; j += 20) {
            sum += *j + *(j+1) + *(j+2) + *(j+3) + *(j+4) + *(j+5) + *(j+6) + *(j+7) + *(j+8) + *(j+9);
            sum1 += *(j+10) + *(j+11) + *(j+12) + *(j+13) + *(j+14) + *(j+15) + *(j+16) + *(j+17) + *(j+18) + *(j+19);
            }

如何解决此错误？顺便说一句，我不想​​要关于尝试优化代码的替代方法的建议。这是一个家庭作业问题，限制了我可以做什么。我想一旦我修复了这个指针问题，它会在 7 秒内运行，我会很高兴的。

Answer 1

不同指针类型的比较缺少强制转换

这意味着您尝试将一种类型的指针与另一种类型的指针进行比较，并且没有进行强制转换。

double  *array = calloc(ARRAY_SIZE, sizeof(double));
int     *j;

指向double 的指针和指向int 的指针不能直接比较。出于这个原因，您不能将j 与array 进行比较。也许您打算将j 声明为指向double 的指针？

Answer 2

C 是一种静态类型语言，跨指针类型的比较会给你错误。在某些情况下存在一些隐式转换，例如将 double 与 int 进行比较，因为比较数字是一种常见操作。比较不同类型的指针不是。

此外，当您在数组上增加指针时，它会使用其取消引用元素的大小来了解要在内存中移动多远。在双精度数组上移动 int 会导致问题。

double 会比 int 移动得更远，所以无论如何你都会得到更多与 int 指针的交互。

您可以显式地强制转换，但实际上您应该使用双 * 来表示双精度数组。

Answer 3

如果从数组表示转移到指针表示会产生很多（如果有的话）加速，我会感到非常惊讶，因为两者都是最终输出代码中的内存地址（和内存偏移量）。请记住，数组表示实际上也是不同服装中的指针表示。

相反，我会考虑以下两种技术之一：

1. 嵌入式 MMX 表示，在同一时钟周期下在同一寄存器内执行多个加法运算。然后，您需要在接近尾声时进行一次操作，以将高双精度与低双精度结合起来。

2. 分散/聚集算法将加法运算分散到多个内核（如今几乎每个 CPU 都有 4 个内核可用，如果不是 16 个伪内核（超线程））

除此之外，您还可以尝试进行一些缓存分析，并将中间体存储在不同的寄存器中。在您的每个计算中似乎都有一个很深的加法链。将它们分解可能会产生将 CPU 上的存储分布到更多寄存器的能力。

大多数操作都受内存限制。 20 是循环展开的一个非常奇怪的边界。双精度数可能是 16 位，因此 20 个双精度数是 320 位，这可能与您的内存高速缓存行大小不一致。尝试确保展开循环的倍数与架构的 1 级缓存完全对齐，并且在跨缓存边界读取时可能会避免页面错误。这样做会加快你的程序一些（但谁知道多少）。

Answer 4

“当你在一个数组上增加一个指针时，它使用它的取消引用元素的大小来知道在内存中移动多远。在一个双精度数组上移动一个 int 会导致问题”。

为了避免您的警告：执行以下操作

for (j= (int *)array; j < (int *)&array[ARRAY_SIZE]; j += 20)