指定64位对齐

Question

Given a structure definition like

struct foo {
    int a, b, c;
};

What's the best (simplest, most reliable and portable) way to specify that it should always be aligned to a 64-bit address, even on a 32-bit build? I'm using C++11 with GCC 4.5.2, and hoping to also support Clang.

Answer 1

Since you say you're using GCC and hoping to support Clang, GCC's aligned attribute should do the trick:

struct foo {
    int a, b, c;
} __attribute__((__aligned__(8))); // aligned to 8-byte (64-bit) boundary

Answer 2

The following is reasonably portable, in the sense that it will work on a lot of different implementations, but not all:

union foo {
    struct {int a, b, c; } data;
    double padding1;
    long long padding2;
};

static char assert_foo_size[sizeof(foo) % 8 == 0 ? 1 : -1];

That will fail to compile unless either:

• the compiler has added some padding to foo to bring it to a multiple of 8, which normally would only happen for reason of an alignment requirement, or
• the layout of foo.data is extremely strange, or
• one of long long and double is bigger than 3 ints, and a multiple of 8. Which doesn't necessarily mean it's 8-aligned.

Given that you only need to support 2 compilers though, and clang is fairly gcc-compatible by design, just use the __attribute__ that works. Only think of doing anything else if you want to write code now that will (hopefully) work on compilers you're not testing on.

C++11 adds alignof , which you can test instead of testing the size. It will remove the false positives, but still leave you with some conforming implementations on which the union fails to create the alignment you want, and hence fails to compile. Also, my sizeof trick is quite limited, it doesn't help at all if your structure has 4 ints instead of only 3, whereas the same thing with alignof does. I don't know what versions of gcc and clang support alignof , which is why I didn't use it to start with. I wouldn't have thought it's difficult to do.

By the way, if instances of foo are dynamically allocated then things get easier. Firstly, I suspect that glibc or similar malloc implementations will 8-align anyway -- if there's a basic type with an 8-byte alignment then malloc has to, and I think glibc malloc just does always, rather than worrying about whether there is or not on any given platform. Secondly, there's posix_memalign to be sure.

Answer 3

You should use __attribute__((aligned(8)) . However, I found this description only make sure allocated size of structure is multiple of 8 Bytes. It does not make sure start address is the multiple.

For example. I use __attribute__((aligned(64)) , malloc may return a 64Byte-length structure whose start address is 0xed2030.

If you want start address is aligned, you should use aligned_alloc: gcc aligned allocation . aligned_alloc(64, sizeof(foo) will return 0xed2040.

Answer 4

Portable? I don't really know about a really portable way. GCC has __attribute__((aligned(8))) , and other compilers may also have equivalents, which you can detect using preprocessor directives.

Answer 5

I'm pretty sure gcc 4.5.2 is old enough that it doesn't support the standard version yet, but C++11 adds some types specifically to deal with alignment -- std::aligned_storage and std::aligned_union among other things (see §20.9.7.6 for more details).

Seems to me that the most obvious way to do this would be to use Boost's implementation of aligned_storage (or TR1's, if you have that). If you don't want that, I'd still think hard about using the standard version in most of your code, and just write a small implementation of it for your own use until you update to a compiler that implements the standard. Portable code, however, will still look slightly different from most that uses something like __declspec(align... or __attribute__(__aligned__, ... directly.

In particular, it just gives you a raw buffer of a requested size with a requested alignment. it's then up to you to use something like placement new to create an object of your type in that storage.

For what it's worth, here's a quick stab at an implementation of aligned_storage based on gcc's __attribute__(__aligned__,... directive:

template <std::size_t Len, std::size_t Alignment>
struct aligned_storage {
    typedef struct {
        __attribute__(__aligned__(Alignment)) unsigned char __data[Len];
    } type;
};

A quick test program to show how to use this:

struct foo {
    int a, b, c;

    void *operator new(size_t, void *in) { return in; }
};

int main() {
    stdx::aligned_storage<sizeof(foo), 8>::type buf;

    foo& f = *new (static_cast<void*>(&buf)) foo();

    int address = *reinterpret_cast<int *>(&f);

    if (address & 0x3 != 0)
        std::cout << "Failed.\n";

    f.~foo();

    return 0;
}

Of course, in real use you'd wrap up/hide most of the ugliness I've shown here. If you leave it like this, the price of (theoretical/future) portability is probably excessive.

Answer 6

[[gnu::aligned(64)]] in c++11 annotation std::atomic <int64_t> ob [[gnu::aligned(64)]]