整数类包装性能

Question

我正在寻找重塑现有库的定点数。目前该库只是名称空间的函数，在32位有符号整数上运行。我想转过头来创建一个固定点类，它包装一个整数，但不希望支付任何与这些细粒度类相关的性能损失，因为性能是用例的一个问题。由于未来的类具有如此简单的数据需求，并且没有资源，我认为有可能使类“价值导向”，利用非修改操作并在合理的地方通过值传递实例。如果实施，这将是一个简单的类，而不是层次结构的一部分。

我想知道是否有可能编写一个整数包装类的方式，没有真正的性能损失发生与使用原始整数相比。我几乎确信，情况确实如此，但对编译过程不太了解，只是跳到其中。

我知道，据说stl iterators被编译为简单的指针操作，并且希望只对整型操作做类似的操作。

作为项目的一部分，该库将作为项目的一部分更新为C++ 11，所以我希望至少通过constexpr和其他新的特性（如右值引用），我可以将此类的性能推到接近纯整数操作。

此外，任何关于两个实现之间的性能差异基准测试的建议将不胜感激。

Answer 1

有什么有趣的这个问题是，它只是使编译器相关的。使用锵/ LLVM：

#include <iostream> 
using namespace std; 

inline int foo(int a) { return a << 1; } 

struct Bar 
{ 
    int a; 

    Bar(int x) : a(x) {} 

    Bar baz() { return a << 1; } 
}; 

void out(int x) __attribute__ ((noinline)); 
void out(int x) { cout << x; } 

void out(Bar x) __attribute__ ((noinline)); 
void out(Bar x) { cout << x.a; } 

void f1(int x) __attribute ((noinline)); 
void f1(int x) { out(foo(x)); } 

void f2(Bar b) __attribute ((noinline)); 
void f2(Bar b) { out(b.baz()); } 

int main(int argc, char** argv) 
{ 
    f1(argc); 
    f2(argc); 
} 

给出the following IR：

define void @_Z3outi(i32 %x) uwtable noinline { 
    %1 = tail call %"class.std::basic_ostream"* 
       @_ZNSolsEi(%"class.std::basic_ostream"* @_ZSt4cout, i32 %x) 
    ret void 
} 

define void @_Z3out3Bar(i32 %x.coerce) uwtable noinline { 
    %1 = tail call %"class.std::basic_ostream"* 
       @_ZNSolsEi(%"class.std::basic_ostream"* @_ZSt4cout, i32 %x.coerce) 
    ret void 
} 

define void @_Z2f1i(i32 %x) uwtable noinline { 
    %1 = shl i32 %x, 1 
    tail call void @_Z3outi(i32 %1) 
    ret void 
} 

define void @_Z2f23Bar(i32 %b.coerce) uwtable noinline { 
    %1 = shl i32 %b.coerce, 1 
    tail call void @_Z3out3Bar(i32 %1) 
    ret void 
} 

而且不出所料，所产生的组件仅仅是相同的：

.globl _Z2f1i 
    .align 16, 0x90 
    .type _Z2f1i,@function 
_Z2f1i:         # @_Z2f1i 
.Ltmp6: 
    .cfi_startproc 
# BB#0: 
    addl %edi, %edi 
    jmp _Z3outi     # TAILCALL 
.Ltmp7: 
    .size _Z2f1i, .Ltmp7-_Z2f1i 
.Ltmp8: 
    .cfi_endproc 
.Leh_func_end2: 


    .globl _Z2f23Bar 
    .align 16, 0x90 
    .type _Z2f23Bar,@function 
_Z2f23Bar:        # @_Z2f23Bar 
.Ltmp9: 
    .cfi_startproc 
# BB#0: 
    addl %edi, %edi 
    jmp _Z3out3Bar    # TAILCALL 
.Ltmp10: 
    .size _Z2f23Bar, .Ltmp10-_Z2f23Bar 
.Ltmp11: 
    .cfi_endproc 
.Leh_func_end3: 

通常，只要在类的方法是内联，this参数和参考可以轻松省略。我不太清楚海湾合作委员会如何搞砸这件事。

Answer 2

impleming值语义的定点运算会产生，因为性能较差......

#include <iostream> 
using namespace std; 

inline int foo(int a) { return a << 1; } 

struct Bar 
{ 
    int a; 

    Bar(int x) : a(x) {} 

    Bar baz() { return a << 1; } 
}; 

void out(int x) __attribute__ ((noinline)); 
void out(int x) { cout << x; } 

void out(Bar x) __attribute__ ((noinline)); 
void out(Bar x) { cout << x.a; } 

void f1(int x) __attribute ((noinline)); 
void f1(int x) { out(foo(x)); } 

void f2(Bar b) __attribute ((noinline)); 
void f2(Bar b) { out(b.baz()); } 

int main(int argc, char** argv) 
{ 
    f1(argc); 
    f2(argc); 
} 

现在，让我们看到了F1和F2拆卸...

00000000004006e0 <f1(int)>: 
    4006e0: 01 ff     add edi,edi 
    4006e2: e9 d9 ff ff ff   jmp 4006c0 <out(int)> 
    4006e7: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0] 
    4006ee: 00 00 

00000000004006f0 <f2(Bar)>: 
    4006f0: 48 83 ec 08    sub rsp,0x8 
    4006f4: 01 ff     add edi,edi 
    4006f6: e8 d5 ff ff ff   call 4006d0 <out(Bar)> 
    4006fb: 48 83 c4 08    add rsp,0x8 
    4006ff: c3      ret  

正如你可以看到F2对堆栈指针有一些额外的麻烦，这也防止了ret被消除。

（这是在-O3 G ++ 4.6.1）