# GAP Message (Diagnostic ID 30754)

## Message

Aligning the fields '%s' in the structure '%s' on an 8-byte boundary may improve performance. Default alignment of double precision floating point data is 4-byte on the Linux IA32 platform. [ALTERNATIVE] Reordering fields of the structure may help to align double precision floating point data on an 8-byte boundary. [ALTERNATIVE] Another way is to use __attribute__((aligned(8))) for the fields '%s' in the structure '%s' to allocate the fields on an 8-byte boundary.

This messsage is only available on Linux* systems.

## Advice

You must reorder the fields of a class or structure type to make "double" fields 8-byte aligned. On Linux* systems on IA-32 architecture, "double" fields are not required to be 8-byte aligned. This should enable optimizations like vectorization to generate better code. You must verify that the application code does not rely on the structure fields to be laid out in a specific order.

## Example

Consider the following:

    //alignment.c
    #include <stdlib.h>
    #include <stdio.h>

    #define N 1000

    struct S {
        int i;
        double d1;
        double d2;
        double d3;
    };

    struct S *sp;

    static struct S*
    alloc_s(int num) {
        struct S * temp;

        temp = calloc(num, sizeof(struct S));
        return temp;
    }

    struct S temp;

    static void
    swap_s(int i, int j) {
        memcpy(&temp, sp + i, sizeof(struct S));
        memcpy(sp + i, sp + j, sizeof(struct S));
        memcpy(sp+ j, &temp, sizeof(struct S));
    }

    static void
    init_s(int num) {
        int ii;

        for (ii = 0; ii < num; ii++) {
            sp[ii].i = ii;
            sp[ii].d1 = (double) ii + 1;
            sp[ii].d2 = (double) ii + 2;
            sp[ii].d3 = (double) ii + 3;
        }
    }

    main() {
        int ii;
        double d = 0.0;

        sp = alloc_s(N);

        for(ii = 0; ii < N -1; ii += 2) {
            swap_s(ii, ii+1);
        }

        for (ii = 0; ii < N ; ii++) {
            sp[ii].d1 = sp[ii].d1 * sp[ii].d2 * sp[ii].d3;
            d += sp[ii].d1;
        }

        for (ii = 0; ii < N ; ii++) {
            printf(" %d:  %g   %g  %g  \n", sp[ii].i, sp[ii].d1, sp[ii].d2, sp[ii].d3);
        }
    }

In this case, when the program is compiled, the compiler generates a message saying that aligning the fields 'd1, d2, d3' in the structure 'S' on an 8-byte boundary may improve performance.

Alternatively, '__attribute__((aligned(8)))' can be used to align 'd1, d2, d3' on an 8-byte boundary. One possible way to do this is shown below:

    struct S {
        int i;
        __attribute__((aligned(8)))  double d1;
        double d2;
        double d3;
    };

## Verify

Make sure that the restructured code satisfies the original program semantics. Note that size of the structure may change due to the alignment changes. Make sure that the change in the structure layout satisfies the original program semantics.

Parent topic: Guided Auto Parallelism Messages