我正在优化在我们应用程序的最内层循环之一中调用的构造函数。有问题的类大约 100 字节宽，由一堆 ints、floats、bools 和琐碎的结构组成，以及应该是可简单复制的(它有一个重要的默认构造函数，但没有析构函数或虚函数)。它的构造足够频繁，以至于在此 ctor 中花费的每 纳秒 时间，我们需要购买大约 6,000 美元的额外服务器硬件。

但是，我发现 GCC 并没有为此构造函数发出非常有效的代码(即使设置了 -O3 -march 等)。 GCC 的构造函数实现，通过初始化列表填充默认值，运行大约需要 34ns。如果我使用手写函数代替这个默认构造函数，该函数使用各种 SIMD 内在函数和指针数学直接写入对象的内存空间，构造大约需要 8ns。

当我 __attribute__ 时，我可以让 GCC 为此类对象发出一个有效的构造函数吗？它们在 SIMD 边界上内存对齐？还是我必须求助于老派的技术，比如在汇编中编写自己的内存初始化程序？

此对象仅在堆栈上构造为本地对象，因此任何 new/malloc 开销都不适用。

上下文:

这个类的使用方式是在堆栈上将其构造为局部变量，选择性地写入一些具有非默认值的字段，然后将其(通过引用)传递给一个函数，该函数将其引用传递给另一个函数，依此类推.

struct Trivial {
  float x,y,z;
  Trivial () : x(0), y(0), z(0) {};
};

struct Frobozz
{
   int na,nb,nc,nd;
   bool ba,bb,bc;
   char ca,cb,cc;
   float fa,fb;
   Trivial va, vb; // in the real class there's several different kinds of these
   // and so on
   Frobozz() : na(0), nb(1), nc(-1), nd(0),
               ba(false), bb(true), bc(false),
               ca('a'), cb('b'), cc('c'),
               fa(-1), fb(1.0) // etc
    {}
} __attribute__(( aligned(16) ));

// a pointer to a func that takes the struct by reference
typedef int (*FrobozzSink_t)( Frobozz& );

// example of how a function might construct one of the param objects and send it
// to a sink. Imagine this is one of thousands of event sources:
int OversimplifiedExample( int a, float b )
{
   Frobozz params; 
   params.na = a; params.fb = b; // other fields use their default values
   FrobozzSink_t funcptr = AssumeAConstantTimeOperationHere();
   return (*funcptr)(params);
}

这里的最佳构造函数将通过从静态"template"实例复制到新构造的实例来工作，理想情况下使用 SIMD 运算符一次工作 16 个字节。相反，GCC 对 OversimplifiedExample() 做了完全错误的事情——一系列立即 mov 操作来逐字节填充结构。

// from objdump -dS
int OversimplifiedExample( int a, float b )
{
     a42:55                   push   %ebp
     a43:89 e5                mov    %esp,%ebp
     a45:53                   push   %ebx
     a46:e8 00 00 00 00       call   a4b <_Z21OversimplifiedExampleif+0xb>
     a4b:5b                   pop    %ebx
     a4c:81 c3 03 00 00 00    add    $0x3,%ebx
     a52:83 ec 54             sub    $0x54,%esp
     // calling the 'Trivial()' constructors which move zero, word by word...
     a55:89 45 e0             mov    %eax,-0x20(%ebp)
     a58:89 45 e4             mov    %eax,-0x1c(%ebp)
     a5b:89 45 e8             mov    %eax,-0x18(%ebp)
     a5e:89 45 ec             mov    %eax,-0x14(%ebp)
     a61:89 45 f0             mov    %eax,-0x10(%ebp)
     a64:89 45 f4             mov    %eax,-0xc(%ebp)
     // filling out na/nb/nc/nd..
     a67:c7 45 c4 01 00 00 00 movl   $0x1,-0x3c(%ebp)
     a71:c7 45 c8 ff ff ff ff movl   $0xffffffff,-0x38(%ebp)
     a78:89 45 c0             mov    %eax,-0x40(%ebp)
     a7b:c7 45 cc 00 00 00 00 movl   $0x0,-0x34(%ebp)
     a82:8b 45 0c             mov    0xc(%ebp),%eax
     // doing the bools and chars by moving one immediate byte at a time!
     a85:c6 45 d0 00          movb   $0x0,-0x30(%ebp)
     a89:c6 45 d1 01          movb   $0x1,-0x2f(%ebp)
     a8d:c6 45 d2 00          movb   $0x0,-0x2e(%ebp)
     a91:c6 45 d3 61          movb   $0x61,-0x2d(%ebp)
     a95:c6 45 d4 62          movb   $0x62,-0x2c(%ebp)
     a99:c6 45 d5 63          movb   $0x63,-0x2b(%ebp)
     // now the floats...
     a9d:c7 45 d8 00 00 80 bf movl   $0xbf800000,-0x28(%ebp)
     aa4:89 45 dc             mov    %eax,-0x24(%ebp)
     // FrobozzSink_t funcptr = GetFrobozz();
     aa7:e8 fc ff ff ff       call   aa8 <_Z21OversimplifiedExampleif+0x68>
     // return (*funcptr)(params);
     aac:8d 55 c0             lea    -0x40(%ebp),%edx
     aaf:89 14 24             mov    %edx,(%esp)
     ab2:ff d0                call   *%eax
     ab4:83 c4 54             add    $0x54,%esp
     ab7:5b                   pop    %ebx
     ab8:c9                   leave 
     ab9:c3                   ret   
}

我试图鼓励 GCC 构造这个对象的单个“默认模板”，然后在默认构造函数中批量复制它，方法是使用一个隐藏的“虚拟”构造函数来制作基本示例和然后有默认的只是复制它:

struct Frobozz
{
     int na,nb,nc,nd;
     bool ba,bb,bc;
     char ca,cb,cc;
     float fa,fb;
     Trivial va, vb;
     inline Frobozz();
private:
     // and so on
     inline Frobozz( int dummy ) : na(0), /* etc etc */     {}
} __attribute__( ( aligned( 16 ) ) );

Frobozz::Frobozz( )
{
     const static Frobozz DefaultExemplar( 69105 );
     // analogous to copy-on-write idiom
     *this = DefaultExemplar;
     // or:
     // memcpy( this, &DefaultExemplar, sizeof(Frobozz) );
}

但是由于一些冗余的堆栈复制，这生成的代码甚至比带有初始化列表的基本默认代码更慢。

最后我求助于编写一个内联的自由函数来执行 *this = DefaultExemplar 步骤，使用编译器内在函数和关于内存对齐的假设来发出 pipelined MOVDQA有效复制结构的 SSE2 操作码。这让我得到了我需要的性能，但它很恶心。我认为我在汇编中编写初始化程序的日子已经过去了，我真的宁愿让 GCC 的优化器首先发出正确的代码。

有什么方法可以让 GCC 为我的构造函数、一些编译器设置或我错过的其他 __attribute__ 生成最佳代码？

这是在 Ubuntu 上运行的 GCC 4.4。编译器标志包括 -m32 -march=core2 -O3 -fno-strict-aliasing -fPIC (等等)。可移植性不是考虑因素，我完全愿意为了性能牺牲标准合规性。

通过使用 rdtsc 直接读取时间戳计数器来执行计时，eg 测量 N 的循环OversimplifiedExample() 样本之间的调用，适当注意计时器分辨率和缓存以及统计显着性等。

当然，我还通过尽可能减少调用站点的数量对此进行了优化，但我仍然想知道如何从 GCC 中获得更好的 ctors。

最佳答案

我会这样做。不要声明任何构造函数；相反，声明一个包含默认值的固定 Frobozz:

const Frobozz DefaultFrobozz =
  {
  0, 1, -1, 0,        // int na,nb,nc,nd;
  false, true, false, // bool ba,bb,bc;
  'a', 'b', 'c',      // char ca,cb,cc;
  -1, 1.0             // float fa,fb;
  } ;

然后在OversimplifiedExample中:

Frobozz params (DefaultFrobozz) ;

使用 gcc -O3(版本 4.5.2)，params 的初始化简化为:

leal    -72(%ebp), %edi
movl    $_DefaultFrobozz, %esi
movl    $16, %ecx
rep movsl

这与它在 32 位环境中的表现差不多。

警告:我在 64 位 g++ 版本 4.7.0 20110827(实验性)上进行了尝试，它生成了一个明确的 64 位拷贝序列，而不是 block 移动。处理器不允许 rep movsq，但我希望 rep movsl 比 64 位加载和存储序列更快。也许不是。 (但是 -Os 开关——优化空间——确实使用了 rep movsl 指令。)无论如何，试试这个，让我们知道会发生什么。

编辑添加:我错了处理器不允许rep movsq。英特尔的文档说“MOVS、MOVSB、MOVSW 和 MOVSD 指令前面可以有 REP 前缀”，但这似乎只是一个文档故障。无论如何，如果我使 Frobozz 足够大，那么 64 位编译器会生成 rep movsq 指令；所以它可能知道自己在做什么。

关于c++ - 可以强制 GCC 为内存对齐对象生成有效的构造函数吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8894695/