189

It is C language.It is written that:

typedef struct __attribute__((packed, aligned(4))) Ball {
    float2 delta;
    float2 position;
    //float3 color;
    float size;
    //int arcID;
    //float arcStr;
} Ball_t;
Ball_t *balls;

Please tell me what is the meaning of it,and how to use this keyword.

Improve this question
2
  • 7
    It's a "type attribute" .. (I found this with "C attribute packed" in Google. Surely others can at least do as good!) Commented Aug 2, 2012 at 3:01
  • 2
    See this question -- though with aligned(4) you probably don't have much to worry about. Commented Aug 2, 2012 at 4:07

4 Answers 4

Reset to default
243

Before answering, I would like to give you some data from Wiki

Data structure alignment is the way data is arranged and accessed in computer memory. It consists of two separate but related issues: data alignment and data structure padding.

When a modern computer reads from or writes to a memory address, it will do this in word sized chunks (e.g. 4 byte chunks on a 32-bit system). Data alignment means putting the data at a memory offset equal to some multiple of the word size, which increases the system's performance due to the way the CPU handles memory.

To align the data, it may be necessary to insert some meaningless bytes between the end of the last data structure and the start of the next, which is data structure padding.

gcc provides functionality to disable structure padding. i.e to avoid these meaningless bytes in some cases. Consider the following structure:

typedef struct
{
     char Data1;
     int Data2;
     unsigned short Data3;
     char Data4;

}sSampleStruct;

sizeof(sSampleStruct) will be 12 rather than 8. Because of structure padding. By default, In X86, structures will be padded to 4-byte alignment: 

typedef struct
{
     char Data1;
     //3-Bytes Added here.
     int Data2;
     unsigned short Data3;
     char Data4;
     //1-byte Added here.

}sSampleStruct;

We can use __attribute__((packed, aligned(X))) to insist particular(X) sized padding. X should be powers of two. Refer here

typedef struct
{
     char Data1;
     int Data2;
     unsigned short Data3;
     char Data4;

}__attribute__((packed, aligned(1))) sSampleStruct;

so the above specified gcc attribute does not allow the structure padding. so the size will be 8 bytes.

If you wish to do the same for all the structures, simply we can push the alignment value to stack using #pragma 

#pragma pack(push, 1)

//Structure 1
......

//Structure 2
......

#pragma pack(pop)
Improve this answer
Sign up to request clarification or add additional context in comments.

If memory store data in 4 byte chunks then why its not adding 2 padding bytes to the unsigned short(its 2 byte long) ? or compiler just add padding bytes to 1st and last members of structure ? can you please clarify it.
@User Plz refer this too. If you still not clear, plz come for help stackoverflow.com/questions/11772553/…
Whoever said these padding bytes are meaningless does not know that misaligned data access is an oddity of x86 architecture. These bytes are necessary to avoid exceptions when processor tries to load - say an integer - data which straddles its natural alignment boundary.
@TanveerBadar they meant that the values of the padding bytes are meaningless, not their presence.
@MorElmaliach Padding happens wrt accessibility of members of the struct. Read the accepted answer of stackoverflow.com/questions/11772553/… thread for more clarity.
124
  • packed means it will use the smallest possible space for struct Ball - i.e. it will cram fields together without padding
  • aligned means each struct Ball will begin on a 4 byte boundary - i.e. for any struct Ball, its address can be divided by 4

These are GCC extensions, not part of any C standard.

Improve this answer

Can you please tell if both, do we add bytes in the end only?
What do you mean with "4 byte boundary"? What does that mean?
@schantischul No, the compiler is free to add these bytes (they are referred to as padding) anywhere it chooses. They are most often put adjacent to char arrays or other data types that are < 32 bits in length (or 64 bits) - depending on the target processor.
@user2762996 A "boundary" is an addressing concept. Is it often most efficient (in time and program space) to align members of a structure to the "word size" of the target processor. This is often 32 or 64 bits in modern computing. In fact, some processors of old did not support unaligned accesses to memory and would trigger execution conditions (though behavior could be emulated in the exception handler). Mathematically, an address that is aligned to some arbitrary boundary is said to be "modulo 0" that size.
That is, aligned4 = !!(addr % 4); will 1 for any address ending in 0, 1, 2, or 3. Similarly aligned8 = !!(addr & 8); will be 1 for any address ending in 0 through 7. These two expressions represent 4 (32 bit) or 8 (64 bit) byte alignments. Try it out.
30

The attribute packed means that the compiler will not add padding between fields of the struct. Padding is usually used to make fields aligned to their natural size, because some architectures impose penalties for unaligned access or don't allow it at all.

aligned(4) means that the struct should be aligned to an address that is divisible by 4.

Improve this answer

Can you please tell if both, do we add bytes in the end only?
6

As the question was well explained by other answers, this answer is intended for adding some examples for the demonstration of the effect of adding the attributes packed or aligned. The environment is x64 linux.

Example 1:

#include <stdio.h>

int main()
{
    struct {
        char c;
        int i;
    } obj[2];

    printf("obj[0] addr: %p, size: %lu\n", &obj[0], sizeof(obj[0]));
    printf(".c addr: %p, .i addr: %p\n", &obj[0].c, &obj[0].i);
    printf("obj[1] addr: %p, size: %lu\n", &obj[1], sizeof(obj[1]));
    printf(".c addr: %p, .i addr: %p\n", &obj[1].c, &obj[1].i);

    return 0;
}

Output 1:

obj[0] addr: 0x7ffe397e2050, size: 8
.c addr: 0x7ffe397e2050, .i addr: 0x7ffe397e2054
obj[1] addr: 0x7ffe397e2058, size: 8
.c addr: 0x7ffe397e2058, .i addr: 0x7ffe397e205c

i.e.
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| c |    rsv    |       i       | c |    rsv    |       i       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
^                               ^
|                               |
obj[0]                         obj[1]

Example 2:

struct __attribute__ ((packed)) {
    char c;
    int i;
} obj[2];

obj[0] addr: 0x7fff82b107ee, size: 5
.c addr: 0x7fff82b107ee, .i addr: 0x7fff82b107ef
obj[1] addr: 0x7fff82b107f3, size: 5
.c addr: 0x7fff82b107f3, .i addr: 0x7fff82b107f4

i.e.
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 8 | 9 | A | B | C | D | E | F | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|        others         | c |       i       | c |       i       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
                        ^                   ^
                        |                   |
                        obj[0]             obj[1]

Example 3:

struct __attribute__ ((packed, aligned (4))) {
    char c;
    int i;
} obj[2];

obj[0] addr: 0x7fffcc3d40d0, size: 8
.c addr: 0x7fffcc3d40d0, .i addr: 0x7fffcc3d40d1
obj[1] addr: 0x7fffcc3d40d8, size: 8
.c addr: 0x7fffcc3d40d8, .i addr: 0x7fffcc3d40d9

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| c |       i       |    rsv    | c |       i       |    rsv    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
^                               ^
|                               |
obj[0]                         obj[1]
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.