优化用于模式填充数组的嵌套循环，以帮助编译器生成高效的 ARM 程序集？

Question

我刚刚被分配重新编写以下 C 函数，以帮助 ARM 编译器生成更高效的汇编代码。有谁知道怎么做？

void some_function(int *data)
{
    int  i, j;

    for (i = 0; i < 64; i++)
    {
        for (j = 0; j < 64; j++)
            data[j + 64*i] = (i + j)/2;
    }
}

Answer 1

首先（正如 Jonathan Leffler 所提到的）编译器可能已经做得很好，以至于试图通过编写特定的 C 代码来进行优化通常在商业上是有问题的，也就是说，您在开发时间上损失的钱比通过稍微快一点的时间赚的钱要多代码。
但有时它是值得的；让我们假设这里是这种情况。

如果您确实进行了优化，请在测量时进行。很有可能编写最终不太优化的代码，因为以微妙的方式，否则可能的编译器优化会被挫败。此外，优化是否有效以及优化的程度取决于环境，即需要在所有潜在环境中进行测量。

好的，经过明智的破解，下面是我演示 cmets 中提出的优化的代码，其中之一是 Jonathan Leffler：

/* Jonathan Leffler */
void some_function(int *data)
{
    int  i, j;
    int  k = 0;

    for (i = 0; i < 64; i++)
    {
        for (j = 0; j < 64; j++)
        {
            data[k++] = (i + j)/2;
        }
    }
}

/* Yunnosch 1, loop unrolling by 2 */
void some_function(int *data)
{
    int  i, j;

    for (i = 0; i < 64; i++)
    {
        for (j = 0; j < 64; j+=2)
            data[j +     64*i] = (i + j  )/2;
            data[j + 1 + 64*i] = (i + j+1)/2;
    }
}

/* Yunnosch 1 and Jonathan Leffler */
void some_function(int *data)
{
    int  i, j;
    int k=0; /* Jonathan Leffler */

    for (i = 0; i < 64; i++)
    {
        for (j = 0; j < 64; j+=2) /* Yunnosch */
        {
            data[k++] = (i + j  )/2;
            data[k++] = (i + j+1)/2; /* Yunnosch */
        }
    }
}

/* Yunnosch 2, avoiding the /2, including Jonathan Leffler */
/* Well, duh. This is harder than I thought... 
   I admit that this is NOT tested, I want to demonstrate the idea.
   Everybody feel free to help the very grateful me with fixing errors. */
void some_function(int *data)
{
    int  i, j;
    int  k=0;

    for (i = 0; i < 32; i++) /* magic numbers I normally avoid, 32 is 64/2 */
    {
        for (j = 0; j < 32; j++)
        {
            data[k     ] = (i + j);
            data[k+1   ] = (i + j);
            data[k  +64] = (i + j);
            data[k+1+64] = (i + j +1);
            k+=2;
        }
        k+=64;
    }
}

最后一个版本基于所需结果中的以下可观察 2x2 组模式，如 2D 解释所示：

00 11 ...
01 12 ...

11 22 ...
12 23 ...
.. ..
.. ..
.. ..
´´´´

Answer 2

优化 C 代码以为特定编译器/处理器生成“更高效的汇编代码”是您通常不应该做的事情。编写清晰易懂的 C 代码，让编译器进行优化。

即使您使用 C 代码进行各种技巧并最终为您的特定编译器/处理器提供“更高效的汇编代码”，结果可能是简单的编译器升级可能会毁掉整个事情，您会必须再次更改 C 代码。

对于像你的代码这样简单的东西，从一开始就用汇编代码编写它。但请注意，您必须成为该处理器/汇编语言的真正专家才能击败一个体面的编译器。

无论如何...如果我们想猜测，这是我的猜测：

void some_function(int *data)
{
    int  i, j, x;

    for (i = 0; i < 64; i++)
    {
        // Handle even i-values
        x = i/2;
        for (j = 0; j < 64; j += 2)
        {
            *data = x;
            ++data;
            *data = x;
            ++data;
            ++x;        // Increment after writing to data twice
        }

        ++i;

        // Handle odd i-values
        x = i/2;
        for (j = 0; j < 64; j += 2)
        {
            *data = x;
            ++data;
            ++x;        // Increment after writing to data once
            *data = x;
            ++data;
        }
    }
}

这个想法是 1) 用指针增量替换数组索引和 2) 用整数增量替换 (i+j)/2。

我没有做过任何测量，所以我不能肯定这会是一个好的解决方案。我将把它留给 OP。

---

与上面的想法相同，但还有一些调整（由@user3386109 提出）

void some_function(int *data)
{
    for (int i = 0; i < 32; i++)
    {
        // when i is even, the output is in matched pairs
        int value = i;
        for (int j = 0; j < 32; j++)
        {
            *data++ = value;
            *data++ = value++;
        }

        // when i is odd, the output starts with a singleton
        // followed by matched pairs, and ending with a singleton
        value = i;
        *data++ = value++;
        for (int j = 0; j < 31; j++)
        {
            *data++ = value;
            *data++ = value++;
        }
        *data++ = value;
    }
}