关于c ++：为什么我观察多重继承比单一更快？

Why am I observing multiple inheritance to be faster than single?

我有以下两个文件：

单一CPP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>
#include <stdlib.h>

using namespace std;

unsigned long a=0;

class A {
public:
virtual int f() __attribute__ ((noinline)) { return a; }
};

class B : public A {
public:
virtual int f() __attribute__ ((noinline)) { return a; }
void g() __attribute__ ((noinline)) { return; }
};

int main() {
cin>>a;
A* obj;
if (a>3)
obj = new B();
else
obj = new A();

unsigned long result=0;

for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result+=obj->f();
}
}

cout<<result<<"
";
}

和

CPP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>
#include <stdlib.h>

using namespace std;

unsigned long a=0;

class A {
public:
virtual int f() __attribute__ ((noinline)) { return a; }
};

class dummy {
public:
virtual void g() __attribute__ ((noinline)) { return; }
};

class B : public A, public dummy {
public:
virtual int f() __attribute__ ((noinline)) { return a; }
virtual void g() __attribute__ ((noinline)) { return; }
};

int main() {
cin>>a;
A* obj;
if (a>3)
obj = new B();
else
obj = new A();

unsigned long result=0;

for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result+=obj->f();
}
}

cout<<result<<"
";
}

我使用的是GCC 3.4.6版，带有标志-O2

这就是我得到的计时结果：

倍数：

1
2
3

real 0m8.635s
user 0m8.608s
sys 0m0.003s

单身：

1
2
3

real 0m10.072s
user 0m10.045s
sys 0m0.001s

另一方面，如果在multiple.cpp中我颠倒了类派生的顺序，那么：

1	class B : public dummy, public A {

然后，我得到以下计时(这比单继承的计时要慢一些，因为代码需要对这个指针进行"thunk"调整，人们可能会预料到这一点)：。-

1
2
3

real 0m11.516s
user 0m11.479s
sys 0m0.002s

知道为什么会这样吗？就循环而言，这三种情况下生成的程序集似乎没有任何区别。还有别的地方需要我看吗？

另外，我已经将进程绑定到一个特定的CPU核心，并且使用sched_r rr以实时优先级运行它。

编辑：这是由神秘主义注意到的，并由我复制。做某事

1	cout <<"vtable:" << (void*)obj << endl;

就在single.cpp中的循环导致single的速度与8.4 s中的多个时钟一样快，就像public a、public dummy一样。

相关讨论

+一个精心设计的有趣问题。
我不希望整数算术的速度依赖于这些值(当然是浮点运算)，但为了确保这一点，将obj->a设置为一个一致的值。
设置为5。把它作为输入，但是是的，所有运行案例都是5个。但正如你自己指出的，这不重要。
什么时候创建对象A的实例？我只看到B的一个新实例，而不是A。
@奥瓦：我不是在谈论全局的价值，它是从控制台读取的。我说的是obj->a，它从未被分配，因此是不确定的。
在任何本地范围内都没有。所以它应该(并且确实)返回全球。
我无法在带有x86 UbuntuVM和GCC4.4.3的核心i7上复制这些数字。你用的是什么CPU？x86还是x64？
@奥瓦：是一个班级成员，不是本地人。
@神秘X64与Xeon X5570 GCC 3.4.6
@或者等等，你正在使用值初始化，不是吗？所以成员应该归零。但江户一〔2〕肯定不会返回全球。
@神秘的，我会在另一台机器上用不同的编译器，当我下班回家并发布结果。
@噢，我有很多不同操作系统的机器，我可以试试这个。我去看看我发现了什么。
好吧。在Core I7 920 Windows 7-VS2010 x64上复制。7.4秒对8.7秒。
@神秘的我猜你的意思是7.4对8.7对1？
哎哟…不，我换了…那就不要重复了…：(
@本，抱歉。我只是在测试什么。我第一次注意到的代码在类中没有in t a、b、c；。不管怎样，我会更新代码，但时间还是一样的。
终于！在Xeon X5482、GCC 4.6.1 X64、Ubuntu上复制
在G++4.2.1、OSX 10.7.3、I5上复制；但是，单个需要7秒，多个需要9秒，更改了基类的顺序后——16秒！
@托马兹，我不确定你是否准确地复制了它。我认为单身比多婚慢。是的，你的结果正是我所期望的。单曲是最快的，然后一个版本的multi，其中一个版本的class a首先出现，另一个版本的class dummy首先出现，这是最慢的。
托马斯是的。那也是。7，9，16也是非常有趣的。
@我不知道为什么我要在把dummy放在A前面的时候期望两倍的运行时间(不过我不太了解vtable的实现)。不管怎样，我在装配上有不同！我的f在另一个函数(带有comment tailcall)中使用了某种JMP，它的长度是原来的两倍。我害怕。
@托马什不是两次。也许7，9，9应该是…所以我说这很有趣。
海湾合作委员会肯定有很有趣的事情发生。打印出vtable会使single运行得和multiple一样快…休斯敦大学。。。
如果你把它放在循环之前，它会使单次运行的速度和多次运行的速度一样快。它看起来像是在以一种消除这种减速的方式处理寄存器分配器…世界跆拳道联盟。。。但是，这种减速必须依赖于数据/地址，因为循环的程序集在单个和多个方面都是相同的。
@神秘的是！我看到的完全一样。也许CPU没有明确地将v-table加载到它的指令缓存中，除非你做不到？(随便想什么就扔什么)

注意，这个答案是非常投机的。

与我对"为什么x比y慢"这类问题的其他一些答案不同，我无法提供可靠的证据来支持这个答案。

在修改了一个小时之后，我认为这是由于三件事情的地址对齐：

obj的地址
A虚拟方法表的地址
f()功能地址

(owagh的回答也暗示了指令对齐的可能性。)

多重继承比单一继承慢的原因并不是因为它"神奇地"快，而是因为单一继承案例遇到了编译器或硬件"问题"。

如果为单个和多个继承案例转储程序集，那么它们在嵌套循环中是相同的(寄存器名和所有内容)。

这是我编译的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
unsigned long a=0;

#ifdef SINGLE
class A {
public:
virtual int f() { return a; }
};

class B : public A {
public:
virtual int f() { return a; }
void g() { return; }
};
#endif

#ifdef MULTIPLE
class A {
public:
virtual int f() { return a; }
};

class dummy {
public:
virtual void g() { return; }
};

class B : public A, public dummy {
public:
virtual int f() { return a; }
virtual void g() { return; }
};
#endif

int main() {
cin >> a;
A* obj;
if (a > 3)
obj = new B();
else
obj = new A();

unsigned long result = 0;

clock_t time0 = clock();

for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result += obj->f();
}
}

clock_t time1 = clock();
cout << (double)(time1 - time0) / CLOCKS_PER_SEC << endl;

cout << result <<"
";
system("pause"); // This is useless in Linux, but I left it here for a reason.
}

嵌套循环的程序集在单继承和多继承情况下都是相同的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

.L5:
call clock
movl $65535, %r13d
movq %rax, %r14
xorl %r12d, %r12d
.p2align 4,,10
.p2align 3
.L6:
movl $65535, %ebx
.p2align 4,,10
.p2align 3
.L7:
movq 0(%rbp), %rax
movq %rbp, %rdi
call *(%rax)
cltq
addq %rax, %r12
subl $1, %ebx
jne .L7
subl $1, %r13d
jne .L6
call clock

然而，我看到的性能差异是：

单程：9.4秒
倍数：8.06秒

Xeon X5482，Ubuntu，GCC 4.6.1 X64。

这使我得出结论，即差异必须依赖于数据。

如果查看该程序集，您将注意到唯一可能具有可变延迟的指令是加载：

1
2
3
4
5

; %rbp = vtable

movq 0(%rbp), %rax ; Dereference function pointer from vtable
movq %rbp, %rdi
call *(%rax) ; Call function pointer - f()

然后在调用f()中进行更多的内存访问。

恰好在单继承示例中，上述值的偏移量不利于处理器。我不知道为什么。~~但我不得不怀疑，这将是缓存银行冲突，类似于此问题图表中的区域2。~~

通过重新排列代码并添加虚拟函数，我可以更改这些偏移量——在很多情况下，这将消除这种速度减慢的现象，并使单个继承的速度与多重继承的速度一样快。

~~例如，删除EDOCX1[10]会反转时间：~~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#ifdef SINGLE
class A {
public:
virtual int f() { return a; }
};

class B : public A {
public:
virtual int f() { return a; }
void g() { return; }
};
#endif

#ifdef MULTIPLE
class A {
public:
virtual int f() { return a; }
};

class dummy {
public:
virtual void g() { return; }
};

class B : public A, public dummy {
public:
virtual int f() { return a; }
virtual void g() { return; }
};
#endif

int main() {
cin >> a;
A* obj;
if (a > 3)
obj = new B();
else
obj = new A();

unsigned long result = 0;

clock_t time0 = clock();

for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result += obj->f();
}
}

clock_t time1 = clock();
cout << (double)(time1 - time0) / CLOCKS_PER_SEC << endl;

cout << result <<"
";
// system("pause");
}

单程：8.06秒

倍数：9.4秒

相关讨论

我不认为应该归咎于缓存库冲突，指令缓存与数据l1(预编码、指令边界等)根本不同，我宁愿怀疑分支预测或函数对齐发生了什么奇怪的事情，但这更具推测性。

是的，这显然只是一个疯狂的猜测。很难测试任何东西，因为对代码的任何修改都会改变所有的偏移量。

我想如果你能暂停执行并检查内存中运行的代码(类似于游戏培训师)，这对你有帮助吗？

是的，我认为一个周期精确的模拟器可以工作。不确定它们是否存在于当前的英特尔机器之外的英特尔本身。

好吧，这似乎是最合理的答案，还有你之前问题中的解释。我会反对这一点，但希望得到更明确的答案。

是的，通常我可以提供一个测试用例，它明确地表明x导致了差异。但是在这里我不能，因为代码的任何更改都会在我的机器上随机地在8.06和9.4秒之间切换时间。即使打印出这些地址也能做到…所以。：(

@神秘的嘿，看看下面我的答案。我想我可能已经弄明白了。

我想我至少对这件事的原因有了进一步的了解。循环的程序集完全相同，但对象文件不同！
对于一开始有cout的循环(即

1
2
3
4
5
6
7
cout <<"vtable:" << *(void**)obj << endl;

for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result+=obj->f();
}
}

我在对象文件中得到以下信息：

1
2
3
4
5
6
7
8
9
10
11
40092d: bb fe ff 00 00 mov $0xfffe,%ebx
400932: 48 8b 45 00 mov 0x0(%rbp),%rax
400936: 48 89 ef mov %rbp,%rdi
400939: ff 10 callq *(%rax)
40093b: 48 98 cltq
40093d: 49 01 c4 add %rax,%r12
400940: ff cb dec %ebx
400942: 79 ee jns 400932 <main+0x42>
400944: 41 ff c5 inc %r13d
400947: 41 81 fd fe ff 00 00 cmp $0xfffe,%r13d
40094e: 7e dd jle 40092d <main+0x3d>

但是，如果没有cout，则循环将变为：-(.cpp优先)

1
2
3
4
5
for (int i=0; i<65535; i++) {
for (int j=0; j<65535; j++) {
result+=obj->f();
}
}

现在，Obj:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
400a54: bb fe ff 00 00 mov $0xfffe,%ebx
400a59: 66 data16
400a5a: 66 data16
400a5b: 66 data16
400a5c: 90 nop
400a5d: 66 data16
400a5e: 66 data16
400a5f: 90 nop
400a60: 48 8b 45 00 mov 0x0(%rbp),%rax
400a64: 48 89 ef mov %rbp,%rdi
400a67: ff 10 callq *(%rax)
400a69: 48 98 cltq
400a6b: 49 01 c4 add %rax,%r12
400a6e: ff cb dec %ebx
400a70: 79 ee jns 400a60 <main+0x70>
400a72: 41 ff c5 inc %r13d
400a75: 41 81 fd fe ff 00 00 cmp $0xfffe,%r13d
400a7c: 7e d6 jle 400a54 <main+0x64>

所以我不得不说，这并不是因为神秘主义所指出的假别名，而是因为编译器/链接器发出的这些nop。
在这两种情况下，组件都是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.L30:
movl $65534, %ebx
.p2align 4,,7
.L29:
movq (%rbp), %rax
movq %rbp, %rdi
call *(%rax)
cltq
addq %rax, %r12
decl %ebx
jns .L29
incl %r13d
cmpl $65534, %r13d
jle .L30

现在，.p2align 4，，7将插入数据/nops，直到下一条指令的指令计数器具有最后四位0，最多7个nops。在没有cout和padding的情况下，p2align后面的指令地址是

1
0x400a59 = 0b101001011001

因为它需要<=7nops来对齐下一条指令，所以它实际上会在对象文件中这样做。
另一方面，对于COUT的情况，在.p2Align之后的指令将在

1
0x400932 = 0b100100110010

需要7个以上的nops才能将其填充到一个可以被16个边界整除的区域。因此，它不这样做。
因此，所花费的额外时间仅仅是由于使用-o2标志编译时编译器用NOP填充代码(为了更好地对齐缓存)，而不是真正由于假别名。
我认为这解决了问题。我正在使用http://sourceware.org/binutils/docs/as/p2align.html作为我的参考，p2align实际上做了什么。

相关讨论

+我喜欢这个。我还考虑了指令对齐的可能性。但我一直没能测试它。

这个答案更具推测性。在修改了5分钟并阅读了神秘的答案之后，得出的结论是这是一个硬件问题：在热循环中生成的代码基本上是相同的，所以编译器没有问题，这使得硬件成为唯一的怀疑。
一些随机的想法：

分支预测

分支(=函数)目标地址的对齐或部分别名

一级缓存在读取同一地址后一直处于热运行状态

宇宙射线

相关讨论

+1对于宇宙射线……

你能详细阐述一下你所说的对齐或部分混叠是什么意思吗？以及这可能对事物产生什么影响？一级缓存运行热实际上应该使它更快而不是更慢？

@从我的答案中我链接到的这个问题可能是StackOverflow上最臭名昭著的例子，在StackOverflow中，对齐和部分混叠可以降低性能。所以这可能是一本很好的书。它如何适用于你的问题还不清楚。任何测试假设的尝试都需要修改代码，这会改变所有东西的对齐方式。所以这是一个我无法击中的移动目标。(正如我通过注释一行无关的代码来反转性能数字所示…)

@owagh在编写一个程序来测试缓存和内存的随机访问时间时，我注意到在一个具有6 mib二级缓存的core2上测试一个正好2 mib的访问模式时，温度跳到了接近限制频率的位置。这只在运行四个核心中的一个时发生，只有2 mib，而不是4，而不是1。这几乎是一个很好的问题。

所以我想我们可以假设它与排列有关，但我们不确定

使用当前代码，编译器可以自由地解除对obj->f()的调用，因为obj不能有除class B之外的任何动态类型。
我建议

1
2
3
4
5
6
7
if (a>3) {
B* objb = new B();
objb->a = 5;
obj = objb;
}
else
obj = new A();

相关讨论

为什么obj不能成为一个A？

因为没有别的说法？

哦，我明白了。智能编译器-不知道它能做到这一点。

我也不知道。让我检查一下……

@戴夫：因为在原始代码中，如果没有执行obj = new B()，它使用了一个不确定的指针，导致了未定义的行为。未定义的行为为编译器提供了进行优化的各种自由。并不是说编译器是聪明的，只是C++语言标准允许这种优化。

不，不过还是一样…更新我的问题以反映这一点。

我的猜测是，就A而言，class B : public dummy, public A有不利的对齐。将dummy填充到16个字节，查看是否有差异。

相关讨论

我想那部分是意料之中的。这个问题是class B : public A和class B : public A, public dummy之间的时间差，有利于多重继承。

是的，这被理解为："正如人们所期望的，多亏了‘雷鸣’式的调整。"

好吧，不知道"thunk"是什么意思

@本·沃伊特这正是我在这两种情况下所期望的。

@没问题。

关于C++：为什么在独立循环中元素的添加比组合循环快得多？

为什么C++中的STDIN读行比Python慢得多？

关于Java：为什么处理一个排序数组比一个未排序数组更快？

关于C++：<比<=更快吗？

c#:为什么不继承List?

关于Java：为什么打印"B"比打印"#"慢得多？

关于C++：为什么我要使用指针而不是对象本身呢？

关于python：为什么[]比list()快？