gpt4 book ai didi

c - 在 C 中,(真的) '<' 比 '!=' 快吗?

转载 作者:太空狗 更新时间:2023-10-29 17:17:09 26 4
gpt4 key购买 nike

这是 DV 的典型问题,所以在发布之前我犹豫了(很多)......

我知道这个question被标记为重复,但我的测试(如果它们好:它们好吗?这是问题的一部分)往往表明情况并非如此。

一开始,我做了一些测试,比较了 for 循环和 while 循环。

这表明 for 循环更好。

但更进一步,暂时或暂时不是重点:区别在于:

for (int l = 0; l < loops;l++) {

for (int l = 0; l != loops;l++) {

如果您运行它(在 Windows 10、Visual Studio 2017 版本下),您会发现第一个比第二个快两倍以上。

很难(对于我这样的新手)理解编译器是否出于某种原因能够优化更多的一个或另一个。但是……

  • 简短的问题

为什么?

  • 较长的问题

完整代码如下:

对于“<”循环:

int forloop_inf(int loops, int iterations)
{
int n = 0;
int x = n;

for (int l = 0; l < loops;l++) {
for (int i = 0; i < iterations;i++) {
n++;
x += n;
}
}

return x;
}

对于 '!=' 循环:

int forloop_diff(int loops, int iterations)
{
int n = 0;
int x = n;

for (int l = 0; l != loops;l++) {
for (int i = 0; i != iterations;i++) {
n++;
x += n;
}
}

return x;
}

在这两种情况下,内部计算都在这里,以避免编译器跳过所有循环。

分别由以下人员调用:

printf("for loop inf %f\n", monitor_int(loops, iterations, forloop_inf, &result));
printf("%d\n", result);

printf("for loop diff %f\n", monitor_int(loops, iterations, forloop_diff, &result));
printf("%d\n", result);

其中循环次数 = 10 * 1000,迭代次数 = 1000 * 1000。

monitor_int 在哪里:

double monitor_int(int loops, int iterations, int(*func)(int, int), int *result)
{
clock_t start = clock();

*result = func(loops, iterations);

clock_t stop = clock();

return (double)(stop - start) / CLOCKS_PER_SEC;
}

以秒为单位的结果是:

for loop inf 2.227 seconds
for loop diff 4.558 seconds

因此,即使与循环本身相比,所有内容的重要性都与循环内部完成的事情的权重有关,为什么会有这样的差异?

编辑:

你可以找到here审查了完整的源代码,以便多次以随机顺序调用函数。

对应的反汇编为here (通过 dumpbin/DISASM CPerf2.exe 获得)。

运行它,我现在得到:

  • '!=' 0.045231(493 次运行的平均值)
  • '<' 0.031010(507 次运行的平均值)

我不知道如何在Visual Studio中设置O3,编译命令行如下:

/permissive- /Yu"stdafx.h" /GS /GL /W3 /Gy /Zc:wchar_t /Zi /Gm- /O2 /sdl /Fd"x64\Release\vc141.pdb" /Zc:inline /fp:precise /D "NDEBUG" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oi /MD /FC /Fa"x64\Release\" /EHsc /nologo /Fo"x64\Release\" /Ot /Fp"x64\Release\CPerf2.pch" /diagnostics:classic

循环的代码在上面,这里是随机运行的方式:

typedef int(loop_signature)(int, int);

void loops_compare()
{
int loops = 1 * 100;
int iterations = 1000 * 1000;
int result;

loop_signature *functions[2] = {
forloop_diff,
forloop_inf
};

int n_rand = 1000;

int n[2] = { 0, 0 };
double cum[2] = { 0.0, 0.0 };

for (int i = 0; i < n_rand;i++) {
int pick = rand() % 2;
loop_signature *fun = functions[pick];

double time = monitor(loops, iterations, fun, &result);
n[pick]++;
cum[pick] += time;
}

printf("'!=' %f (%d) / '<' %f (%d)\n", cum[0] / (double)n[0], n[0], cum[1] / (double)n[1], n[1]);
}

和反汇编(仅循环功能,但不确定它是否是上面链接的良好摘录):

?forloop_inf@@YAHHH@Z:
0000000140001000: 48 83 EC 08 sub rsp,8
0000000140001004: 45 33 C0 xor r8d,r8d
0000000140001007: 45 33 D2 xor r10d,r10d
000000014000100A: 44 8B DA mov r11d,edx
000000014000100D: 85 C9 test ecx,ecx
000000014000100F: 7E 6F jle 0000000140001080
0000000140001011: 48 89 1C 24 mov qword ptr [rsp],rbx
0000000140001015: 8B D9 mov ebx,ecx
0000000140001017: 66 0F 1F 84 00 00 nop word ptr [rax+rax]
00 00 00
0000000140001020: 45 33 C9 xor r9d,r9d
0000000140001023: 33 D2 xor edx,edx
0000000140001025: 33 C0 xor eax,eax
0000000140001027: 41 83 FB 02 cmp r11d,2
000000014000102B: 7C 29 jl 0000000140001056
000000014000102D: 41 8D 43 FE lea eax,[r11-2]
0000000140001031: D1 E8 shr eax,1
0000000140001033: FF C0 inc eax
0000000140001035: 8B C8 mov ecx,eax
0000000140001037: 03 C0 add eax,eax
0000000140001039: 0F 1F 80 00 00 00 nop dword ptr [rax]
00
0000000140001040: 41 FF C1 inc r9d
0000000140001043: 83 C2 02 add edx,2
0000000140001046: 45 03 C8 add r9d,r8d
0000000140001049: 41 03 D0 add edx,r8d
000000014000104C: 41 83 C0 02 add r8d,2
0000000140001050: 48 83 E9 01 sub rcx,1
0000000140001054: 75 EA jne 0000000140001040
0000000140001056: 41 3B C3 cmp eax,r11d
0000000140001059: 7D 06 jge 0000000140001061
000000014000105B: 41 FF C2 inc r10d
000000014000105E: 45 03 D0 add r10d,r8d
0000000140001061: 42 8D 0C 0A lea ecx,[rdx+r9]
0000000140001065: 44 03 D1 add r10d,ecx
0000000140001068: 41 8D 48 01 lea ecx,[r8+1]
000000014000106C: 41 3B C3 cmp eax,r11d
000000014000106F: 41 0F 4D C8 cmovge ecx,r8d
0000000140001073: 44 8B C1 mov r8d,ecx
0000000140001076: 48 83 EB 01 sub rbx,1
000000014000107A: 75 A4 jne 0000000140001020
000000014000107C: 48 8B 1C 24 mov rbx,qword ptr [rsp]
0000000140001080: 41 8B C2 mov eax,r10d
0000000140001083: 48 83 C4 08 add rsp,8
0000000140001087: C3 ret
0000000140001088: CC CC CC CC CC CC CC CC ÌÌÌÌÌÌÌÌ
?forloop_diff@@YAHHH@Z:
0000000140001090: 45 33 C0 xor r8d,r8d
0000000140001093: 41 8B C0 mov eax,r8d
0000000140001096: 85 C9 test ecx,ecx
0000000140001098: 74 28 je 00000001400010C2
000000014000109A: 44 8B C9 mov r9d,ecx
000000014000109D: 0F 1F 00 nop dword ptr [rax]
00000001400010A0: 85 D2 test edx,edx
00000001400010A2: 74 18 je 00000001400010BC
00000001400010A4: 8B CA mov ecx,edx
00000001400010A6: 66 66 0F 1F 84 00 nop word ptr [rax+rax]
00 00 00 00
00000001400010B0: 41 FF C0 inc r8d
00000001400010B3: 41 03 C0 add eax,r8d
00000001400010B6: 48 83 E9 01 sub rcx,1
00000001400010BA: 75 F4 jne 00000001400010B0
00000001400010BC: 49 83 E9 01 sub r9,1
00000001400010C0: 75 DE jne 00000001400010A0
00000001400010C2: C3 ret
00000001400010C3: CC CC CC CC CC CC CC CC CC CC CC CC CC ÌÌÌÌÌÌÌÌÌÌÌÌÌ

再次编辑:

让我感到意外的还有以下几点:

  • 在 debug more 中性能是一样的(汇编代码也是)
  • 那么,如果之后出现此类差异,如何对您正在编码的内容充满信心呢? (考虑到我没有在某处犯错)

最佳答案

为了进行适当的基准测试,以随机顺序多次运行函数非常重要。

typedef int(signature)(int, int);

...

int main() {
int loops, iterations, runs;

fprintf(stderr, "Loops: ");
scanf("%d", &loops);
fprintf(stderr, "Iterations: ");
scanf("%d", &iterations);
fprintf(stderr, "Runs: ");
scanf("%d", &runs);

fprintf(stderr, "Running for %d loops and %d iterations %d times.\n", loops, iterations, runs);

signature *functions[2] = {
forloop_inf,
forloop_diff
};

int result = functions[0](loops, iterations);
for( int i = 0; i < runs; i++ ) {
int pick = rand() % 2;
signature *function = functions[pick];

int new_result;
printf("%d %f\n", pick, monitor_int(loops, iterations, function, &new_result));
if( result != new_result ) {
fprintf(stderr, "got %d expected %d\n", new_result, result);
}
}
}

有了这个,我们可以随机运行 1000 次并找到平均时间。

在启用优化的情况下进行基准测试也很重要。询问未优化代码的运行速度有多快没有多大意义。我会尝试 -O2-O3 .

我的发现是 Apple LLVM version 8.0.0 (clang-800.0.42.1)-O2 处执行 10000 次循环和 1000000 次迭代forloop_inf确实比 forloop_diff 快了大约 50% .

forloop_inf: 0.000009
forloop_diff: 0.000014

查看the generated assembly code for -O2clang -O2 -S -mllvm --x86-asm-syntax=intel test.c我可以看到 many differences between the two implementations .也许了解汇编的人可以告诉我们原因。

但是在 -O3性能差异不再明显。

forloop_inf: 0.000002
forloop_diff: 0.000002

这是因为at -O3 they are almost exactly the same .一个正在使用 je 一个正在使用 jle .就是这样。


总而言之,当进行基准测试时......

  • 跑很多次。
  • 随机排序。
  • 尽可能像在生产环境中那样编译和运行。
    • 在这种情况下,这意味着打开编译器优化。
  • 查看汇编代码。

最重要的是。

  • 选择最安全的代码,而不是最快的代码。

i < maxi != max 更安全因为如果 i 它仍然会终止以某种方式跳过max .

正如所展示的那样,启用优化后,它们都非常快,即使没有完全优化,它们也可以在 0.000009 秒内完成 10,000,000,000 次迭代。 i < maxi != max不太可能成为性能瓶颈,无论您做什么 100 亿次都是。

但是i != max可能会导致错误。

关于c - 在 C 中,(真的) '<' 比 '!=' 快吗?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/50591174/

26 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com