x>-1 vs x>=0，是否存在性能差异

Question

if (x > -1){
    //do stuff
}

if (x >= 0){
    //do stuff
} 

根据这位老师的说法，>会比>=稍微快一点。在本例中，它是Java，但据他说，这也适用于C、C++和其他语言。这种说法有道理吗？

Answer 1

在现实世界中没有任何区别。

让我们看看各种编译器为各种目标生成的一些代码。

>

我假设一个带符号的int操作（这似乎是操作的意图）

通过调查，我仅限于C和手头手头的编译器（诚然是一个相当小的示例-GCC、MSVC和IAR)

已启用基本优化(-O2用于GCC，/ox用于MSVC，-OH用于IAR)

使用以下模块：

void my_puts(char const* s);

void cmp_gt(int x) 
{
    if (x > -1) {
        my_puts("non-negative");
    }
    else {
        my_puts("negative");
    }
}

void cmp_gte(int x) 
{
    if (x >= 0) {
        my_puts("non-negative");
    }
    else {
        my_puts("negative");
    }
}

// if (x > -1) {...
00000        |cmp_gt| PROC
  00000 f1b0 3fff    cmp         r0,#0xFFFFFFFF
  00004 dd05         ble         |$LN2@cmp_gt|


// if (x >= 0) {...
  00024      |cmp_gte| PROC
  00024 2800         cmp         r0,#0
  00026 db05         blt         |$LN2@cmp_gte|

// if (x > -1) {...
cmp_gt  PROC
  00000 83 f9 ff     cmp     ecx, -1
  00003 48 8d 0d 00 00                  // speculative load of argument to my_puts()
    00 00        lea     rcx, OFFSET FLAT:$SG1359
  0000a 7f 07        jg  SHORT $LN5@cmp_gt

// if (x >= 0) {...
cmp_gte PROC
  00000 85 c9        test    ecx, ecx
  00002 48 8d 0d 00 00                  // speculative load of argument to my_puts()
    00 00        lea     rcx, OFFSET FLAT:$SG1367
  00009 79 07        jns     SHORT $LN5@cmp_gte

MSVC 11针对x86:

// if (x > -1) {...
_cmp_gt PROC
  00000 83 7c 24 04 ff   cmp     DWORD PTR _x$[esp-4], -1
  00005 7e 0d        jle     SHORT $LN2@cmp_gt


// if (x >= 0) {...
_cmp_gte PROC
  00000 83 7c 24 04 00   cmp     DWORD PTR _x$[esp-4], 0
  00005 7c 0d        jl  SHORT $LN2@cmp_gte

GCC 4.6.1针对x64

// if (x > -1) {...
cmp_gt:
    .seh_endprologue
    test    ecx, ecx
    js  .L2

// if (x >= 0) {...
cmp_gte:
    .seh_endprologue
    test    ecx, ecx
    js  .L5

以x86为目标的GCC 4.6.1:

// if (x > -1) {...
_cmp_gt:
    mov eax, DWORD PTR [esp+4]
    test    eax, eax
    js  L2

// if (x >= 0) {...
_cmp_gte:
    mov edx, DWORD PTR [esp+4]
    test    edx, edx
    js  L5

// if (x > -1) {...
cmp_gt:
    .fnstart
.LFB0:
    cmp r0, #0
    blt .L8

// if (x >= 0) {...
cmp_gte:
    .fnstart
.LFB1:
    cmp r0, #0
    blt .L2

// if (x > -1) {...
cmp_gt:
80B5 PUSH     {R7,LR}
.... LDR.N    R1,??DataTable1  ;; `?<Constant "non-negative">`
0028 CMP      R0,#+0
01D4 BMI.N    ??cmp_gt_0

// if (x >= 0) {...
cmp_gte:
 80B5 PUSH     {R7,LR}
 .... LDR.N    R1,??DataTable1  ;; `?<Constant "non-negative">`
 0028 CMP      R0,#+0
 01D4 BMI.N    ??cmp_gte_0

null

注意，GCC和IAR为两种比较生成了相同的机器代码（可能使用了寄存器除外）。因此，根据这项调查，(x>=0)似乎有一个非常小的“更快”的机会。但是，无论最短操作码字节编码可能有什么优势（我强调可能有什么优势），肯定会被其他因素完全掩盖。

如果您发现Java或C#的jitted输出有什么不同，我会很惊讶。我怀疑你会发现任何不同，即使是一个非常小的目标，如8位AVR。

总之，不用担心这个微优化。我认为我在这里的写作已经花费了更多的时间，而这些表达式在我有生之年执行它们的所有CPU上累积的性能差异将会花费更多的时间。如果你有能力测量性能上的差异，请把你的努力用在一些更重要的事情上，比如研究亚原子粒子的行为之类的。