Выравнивание удваивается на 8-байтовых границах?

Question

Существует ли распространенная переносимая идиома в числовом коде (я пишу на D, но мне не помешали бы и языковые, C и C ++ ответы), чтобы гарантировать, что все двойники, выделяемые стеком, к которым часто обращаются выровнен по 8-байтовым границам? В настоящее время я оптимизирую некоторый числовой код, в котором неправильно выровненные двойники, выделенные в стеке (выровненные только по 4-байтовым границам), вызывают увеличение производительности примерно в 1,5-2 раза.

Answer 1

Это зависит от компилятора. С GCC на x86 вы бы использовали

-malign-double

Answer 2

В 'C' вы бы использовали объединение для принудительного выравнивания, если вы не хотите полагаться на параметры или директивы компилятора:

#include <stdint.h>

typedef union _foo
{
  uint64_t align;
  double d;
} foo

Это гарантирует, что ваши двойники выровнены по 64-битным кодам, а просто делает доступ к ним более утомительным.

В качестве альтернативы, если вы не возражаете, полагаясь на компилятор, gcc поддерживает директиву #pragma pack(64), которая обеспечивает 64-битное выравнивание для всего.

Answer 3

В C ++ вы можете использовать __declspec (align (#)) вроде:

    __declspec(align(32)) struct Str1{
   int a, b, c, d, e;    };

или более подходящий для того, что вы ищете, двойное выравнивание на 32-битной границе:

__declspec(align(32)) double a;

Есть хорошая статья о настройке данных в Windows здесь , вы можете проверить это.

Answer 4

в D вы можете попробовать выровнять атрибут или функцию библиотеки alignForSize

http://www.digitalmars.com/d/2.0/attribute.html#align

struct S
{   align(4) byte a;    // placed at offset 0
    align(4) byte b;    // placed at offset 1
}

align (1) struct S
{   byte a; // placed at offset 0
    byte[3] filler1;
    byte b; // placed at offset 4
    byte[3] filler2;
}

http://www.digitalmars.com/d/2.0/phobos/std_typecons.html#alignForSize

struct Banner {
  mixin(alignForSize!(byte[6], double)(["name", "height"]));
}