找出最少3个数字的最快方法？

Question

在我编写的一个程序中，20% 的时间都花在了在内循环中找出 3 个数字中的最小值，在这个例程中：

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{
    unsigned int m = a;
    if (m > b) m = b;
    if (m > c) m = c;
    return m;
}

有什么方法可以加快速度吗？我也可以使用 x86/x86_64 的汇编代码。

编辑：回复一些 cmets：
* 使用的编译器是 gcc 4.3.3
* 就组装而言，我只是那里的初学者。我在这里要求组装，以学习如何做到这一点。 :)
* 我运行的是四核 Intel 64，因此支持 MMX/SSE 等。
* 在这里发布循环很困难，但我可以告诉你这是对 levenshtein 算法的高度优化的实现。

这是编译器为 min 的非内联版本提供的内容：

.globl min
    .type   min, @function
min:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %edx
    movl    12(%ebp), %eax
    movl    16(%ebp), %ecx
    cmpl    %edx, %eax
    jbe .L2
    movl    %edx, %eax
.L2:
    cmpl    %ecx, %eax
    jbe .L3
    movl    %ecx, %eax
.L3:
    popl    %ebp
    ret
    .size   min, .-min
    .ident  "GCC: (Ubuntu 4.3.3-5ubuntu4) 4.3.3"
    .section    .note.GNU-stack,"",@progbits

内联版本在 -O2 优化代码中（甚至我的标记 mrk = 0xfefefefe，在调用 min() 之前和之后）都被 gcc 优化掉了，所以我无法掌握它。

更新：我测试了 Nils 建议的更改，ehemient，但是使用 min() 的汇编版本没有明显的性能提升。但是，通过使用 -march=i686 编译程序，我得到了 12.5% 的提升，我猜这是因为整个程序正在受益于 gcc 使用此选项生成的新的更快指令。谢谢你们的帮助。

附： - 我使用 ruby​​ 分析器来测量性能（我的 C 程序是一个由 ruby​​ 程序加载的共享库），所以我只能花时间在 ruby​​ 程序调用的顶级 C 函数上，最终调用 min( ) 在堆栈中。请看这个question。

Answer 1

首先确保您使用的是适当的-march 设置。 GCC 默认不使用原始 i386 不支持的任何指令 - 允许它使用更新的指令集有时会产生很大的不同！在-march=core2 -O2 我得到：

min:
    pushl   %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %edx
    movl    12(%ebp), %ecx
    movl    16(%ebp), %eax
    cmpl    %edx, %ecx
    leave
    cmovbe  %ecx, %edx
    cmpl    %eax, %edx
    cmovbe  %edx, %eax
    ret

在这里使用 cmov 可以帮助您避免分支延迟 - 您只需传入 -march 即可在没有任何内联 asm 的情况下获得它。当内联到更大的函数中时，这可能会更加高效，可能只有四个组装操作。如果您需要比这更快的东西，请查看是否可以让 SSE 向量运算在您的整体算法的上下文中工作。

Answer 2

假设你的编译器没有出去吃午饭，这应该编译成两个比较和两个条件移动。没有比这更好的了。

如果您发布编译器实际生成的程序集，我们可以查看是否有任何不必要的东西减慢了它的速度。

要检查的第一件事是例程实际上是内联的。编译器没有义务这样做，如果它正在生成一个函数调用，那么对于这样一个简单的操作来说，这将是非常昂贵的。

如果调用确实是内联的，那么循环展开可能是有益的，正如 DigitalRoss 所说，或者向量化可能是可能的。

编辑：如果您想对代码进行矢量化，并且使用最新的 x86 处理器，您将需要使用 SSE4.1 pminud 指令（内在：_mm_min_epu32），它接受两个向量，每个向量包含四个无符号整数，并生成一个包含四个无符号整数的向量。结果的每个元素都是两个输入中对应元素的最小值。

我还注意到您的编译器使用分支而不是条件移动；您可能应该先尝试一个使用条件移动的版本，看看这是否能让您在开始矢量实现的竞赛之前获得任何加速。

Answer 3

这款嵌入式替换时钟在我的 AMD Phenom 上的速度提高了约 1.5%：

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{
    asm("cmp   %1,%0\n"
        "cmova %1,%0\n"
        "cmp   %2,%0\n"
        "cmova %2,%0\n"
        : "+r" (a) : "r" (b), "r" (c));
    return a;
}

结果可能会有所不同；一些 x86 处理器不能很好地处理 CMOV。

Answer 4

我对 x86 汇编器实现的看法，GCC 语法。翻译成另一种内联汇编语法应该很简单：

int inline least (int a, int b, int c)
{
  int result;
  __asm__ ("mov     %1, %0\n\t"
           "cmp     %0, %2\n\t" 
           "cmovle  %2, %0\n\t"
           "cmp     %0, %3\n\t"
           "cmovle  %3, %0\n\t" 
          : "=r"(result) : 
            "r"(a), "r"(b), "r"(c)
          );
  return result;
}

---

新的和改进的版本：

int inline least (int a, int b, int c)
{
  __asm__ (
           "cmp     %0, %1\n\t" 
           "cmovle  %1, %0\n\t"
           "cmp     %0, %2\n\t"
           "cmovle  %2, %0\n\t" 
          : "+r"(a) : 
            "%r"(b), "r"(c)
          );
  return a;
}

---

注意：它可能会也可能不会比 C 代码快。

这取决于很多因素。如果分支不可预测（在某些 x86 架构上），通常 cmov 会获胜

顺便说一句，Sudhanshu，听听这段代码如何处理您的测试数据会很有趣。

Answer 5

SSE2 指令扩展包含一个整数 min 指令，一次可以选择 8 个最小值。见_mm_mulhi_epu16http://www.intel.com/software/products/compilers/clin/docs/ug_cpp/comm1046.htm

Answer 6

首先，看反汇编。这会告诉你很多。例如，如所写，有 2 个 if 语句（这意味着有 2 个可能的分支错误预测），但我的猜测是，一个体面的现代 C 编译器将有一些巧妙的优化，可以在没有分支的情况下做到这一点。我很想知道。

其次，如果您的 libc 具有特殊的内置最小/最大功能，请使用它们。例如，GNU libc 具有用于浮点的 fmin/fmax，他们声称“在某些处理器上，这些函数可以使用特殊的机器指令来比等效的 C 代码更快地执行这些操作”。也许 uint 也有类似的东西。

最后，如果您要对一堆数字并行执行此操作，则可能有向量指令可以执行此操作，这可以显着加快速度。但是我什至看到非向量代码在使用向量单位时会更快。诸如“将一个 uint 加载到向量寄存器中，调用向量 min 函数，得到结果”之类的东西看起来很愚蠢，但实际上可能更快。

Answer 7

如果您只进行一次比较，您可能需要手动展开循环。

首先，看看你是否可以让编译器为你展开循环，如果你不能，你自己做。这至少会减少循环控制开销...

Answer 8

您可以尝试这样的方法来节省声明和不必要的比较：

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{ 
    if (a < b)
    {
        if (a < c) 
             return a; 
        else 
             return c;
    }

    if (b < c)
        return b;
    else return c;
}

Answer 9

这些都是很好的答案。冒着被指责不回答问题的风险，我也会在其他 80% 的时间里看看。 Stackshots 是我最喜欢的查找值得优化的代码的方法，尤其是当您发现自己并不绝对需要的函数调用时。

Answer 10

是的，后组装，但我天真的优化是：

static inline unsigned int
min(unsigned int a, unsigned int b, unsigned int c)
{
    unsigned int m = a;
    if (m > b) m = b;
    if (m > c) return c;
    return m;
}