Thread: Structure padding to 16 bytes for use with atomic instructions - like, WTH?

Gents,

I am using atomic instructions on x64 and variables so used must be 16 byte aligned.

I use a number of structures where their members are so operated upon.

The structures accordingly needs must be 16 byte aligned and padded - their internal members must be on 16 byte boundaries and, crucially, there must be tail padding to a 16 byte boundary, so I can allocate arrays of these structures and use pointer math to iterate.

(I am naturally using aligned malloc).

The problem I am finding is that it is not apparent to me how to achieve this end.

Here below we have a test structure (currently I'm working with the latest Amazon Linux GCC, 4.6.3, on x64);

Code:

#define LFDS700_ALIGN_DOUBLE_POINTER 16
#define LFDS700_ALIGN(alignment)  __attribute__( (aligned(alignment)) )

LFDS700_ALIGN(LFDS700_ALIGN_DOUBLE_POINTER) struct test_element
{
  struct lfds700_freelist_element
    fe;

  lfds700_atom_t
    thread_number;

  unsigned int
    datum;
};

This in turn contains as you have seen a struct lfds700_freelist_element, thus (PAC_SIZE is 2);

Code:

LFDS700_ALIGN(LFDS700_ALIGN_DOUBLE_POINTER) struct lfds700_freelist_element
{
  struct lfds700_freelist_element
    *next[PAC_SIZE];

  void const
    *user_data;
};

I allocate an array of test elements, thus;

Code:

te_array = abstraction_aligned_malloc( sizeof(struct test_element) * 100000, LFDS700_ALIGN_DOUBLE_POINTER );

The problem manifest is that sizeof(struct test_element) is 40 bytes!

So the second element does not begin on a 16 byte boundary and we all fall down.

Printing the addresses of the first element in the test element array, I see the following;

Code:

(gdb) print *ts->te_array
$2 = {fe = {next = {0x7fffec0008d0, 0x2}, user_data = 0x7fffdc0008d0}, thread_number = 3, datum = 0}
(gdb) print sizeof(struct test_element)
$3 = 40
(gdb) print &ts->te_array->fe.next
$4 = (struct lfds700_freelist_element *(*)[2]) 0x7fffdc0008d0 (16 bytes long and aligned on 16 bytes)
(gdb) print &ts->te_array->fe.user_data
$5 = (const void **) 0x7fffdc0008e0 (8 bytes long and aligned on 16 bytes)
(gdb) print &ts->te_array->thread_number
$6 = (lfds700_atom_t *) 0x7fffdc0008e8 (8 bytes long and aligned on 8 bytes)
(gdb) print &ts->te_array->datum
$7 = (unsigned int *) 0x7fffdc0008f0 (8 bytes long and aligned on 16 bytes)

So we see fe->next is the first element and so is correctly aligned curtsey of aligned malloc, where fe->next is 16 bytes, fe->user_data is correctly aligned, but then te->thread_number is misaligned and te->datum is given eight bytes rather than four, leaving us in the end without correct tail padding to a 16 byte boundary.

So, what gives? how *am* I supposed to indicate to the compiler it must pad structures to 16 byte boundaries?

Add padding member to the struct?

The problem manifest is that sizeof(struct test_element) is 40 bytes!

O_o

The alignment would not honor the size of structure members the way you've written the code.

The alignment would only apply to the structure proper as allocated by the compiler.

You need to change the alignment for each member within the structure which would change the size so, with an aligned `malloc', could be allocated accordingly the alignment of each member of the array.

(In other words, apply the alignment required directly to the members of the structure.)

Soma

I see what you're saying, but in fact even the latter is not occurring, as the size of the struct is 40, rather than an integer multiple of 16.

O_o

You have misunderstood.

You are not using the feature correctly.

Alignment without tailing padding is half-baked as it cannot be used in arrays.

Indeed.

That is why the compiler will pad the structure to the appropriate multiple when used correctly.

[Edit]
I would have just told you to search for examples, but I wanted to make sure the hint behind my words had a specific example.
[/Edit]

Soma

Code:

#define align __attribute__( (aligned(16)) )

struct align STest1
{
    char a1;
    int b1;
    char c1;
    double d1;
    char e1;
    double d2;
    char c2;
    int b2;
    char a2;
};

struct STest2
{
    align char a1;
    align int b1;
    align char c1;
    align double d1;
    align char e1;
    align double d2;
    align char c2;
    align int b2;
    align char a2;
};

struct STest3_imp
{
    char a1;
    int b1;
    char c1;
    double d1;
    char e1;
    double d2;
    char c2;
    int b2;
    char a2;
};

struct STest3
{
    align struct STest3_imp data; // This is what I was hinting.
};

#include <stdio.h>

int main()
{
    printf("%d\n", (int)sizeof(STest1));
    printf("%d\n", (int)sizeof(STest2));
    printf("%d\n", (int)sizeof(STest3));
    return(0);
}