Shulou(Shulou.com)06/03 Report--

7.1attribute declaration: aligned

GNU C declares the aligned and packed properties through attribute, specifying the alignment of a variable or type. These two properties are used to tell the compiler that when you allocate storage space to a variable, you should assign an address to the variable in the specified address alignment. If you want to define a variable that is aligned with an 8-byte address in memory, you can define it this way.

Int a _ attribute__ ((aligned (8)

Through the aligned attribute, we can directly explicitly specify the address alignment of the variable an in memory. Aligned has a parameter that indicates that if you want to align by a few bytes, you should note that the number of bytes aligned by the address must be the power of 2, otherwise the compilation will go wrong.

What is data alignment?

In general, when we define a variable, the compiler assigns a storage address to the variable in the default address alignment. If the variable is an int type data, the compiler will align by 4 bytes or a multiple of 4 bytes; if the variable is a short type data, the compiler will align by 2 bytes or 2 bytes; if it is a variable of type char, the compiler will align by 1 byte.

Int a = 1; int b = 2; char C1 = 3; char c2 = 4; int main (void) {printf ("a:% p\ n", & a); printf ("b:% p\ n", & b); printf ("c1char% p\ n", & C1); printf ("c2ma% p\ n", & c2); return 0;}

In the above program, we define 2 int-type variables and 2 char-type variables, and then print their addresses. The results are as follows.

A: 00402000b: 00402004c1: 00402008c2: 00402009

From the running results, we can see that for int data, its address in memory is aligned with 4 bytes or 4 bytes. Data of type char, on the other hand, is aligned at 1 byte in memory. The variable c2 is allocated directly to the next storage unit of the C1 variable, without having to consider 4-byte alignment like int data. Next, let's modify the program to specify that the variable c2 is aligned to 4 bytes.

Int a = 1; int b = 2; char C1 = 3; char c2 _ attribute__ ((aligned (4) = 4; int main (void) {printf ("a:% p\ n", & a); printf ("b:% p\ n", & b); printf ("C1 printf% p\ n", & C1); printf ("c2printf% p\ n", & c2); return 0;}

The running results are as follows.

A: 00402000b: 00402004c1: 00402008c2: 0040200C

As you can see from the running results, because the character variable c2 is declared to be aligned to a 4-byte boundary using the aligned attribute, it is no longer possible for the compiler to assign the 0x00402009 address to it, because the address is not 4-byte aligned. The compiler vacates 3 byte units and allocates storage space for the variable c2 directly from the address of 0x0040200C.

Why data alignment?

Through the property declaration of aligned, although we can explicitly specify the address alignment of variables, it will also cause a certain memory hole and waste a certain amount of memory space due to boundary alignment. For example, in the above program, the storage units of the three address spaces 0x00402009~0x0040200b are not used.

Since address alignment creates a certain memory hole, why should we store data in this alignment? One of the main reasons is that this alignment setting simplifies the interface and hardware design between CPU and memory RAM. For example, in a 32-bit computer system, when CPU reads memory, the hardware design may only support 4-byte or 4-byte multiple-aligned address access. Each time CPU reads and writes data to memory RAM, it can read and write 4 bytes in a cycle. If we put a data on a 4-byte-aligned address, then CPU can read and write the data at once; if we put an int-type data on a non-4-byte-aligned address, then CPU will have to read and write the 4-byte data twice.

In order to cooperate with the hardware design of the computer, when compiling the program, the compiler will align the addresses of some basic data types, such as int, char, short, float, etc., according to the size of their data types, and CPU can read and write the storage addresses assigned according to this address alignment. Although boundary alignment can cause some memory holes and waste some memory cells, the hardware design is greatly simplified. This is why when the compiler assigns addresses to the variables we define, different types of variables are aligned with different byte addresses.

In addition to basic type data such as int, char, short, and float, address alignment requirements should also be met for some compound type data.

7.2 alignment of structures

Structure as a compound data type, when allocating storage space to a structure variable, the compiler should consider not only the address alignment of the basic members in the structure, but also the alignment of the structure as a whole. In order to align the member addresses in the body of the structure, the compiler may fill some space in the body of the structure; to align the structure as a whole, the compiler may fill some space at the end of the structure.

Next, we define a structure, which defines three members: int, char and short, and prints the size of the structure and the address of each member.

Struct data {char a; int b; short c;} int main (void) {struct data s; printf ("size:%d\ n", sizeof (s)); printf ("aRV% p\ n", & s.a); printf ("BRV% p\ n", & s.b); printf ("CRAV% p\ n", & s.c);}

The running result of the program is as follows.

Size: 12 & s.a: 0028FF30 & s.b: 0028FF34 & s.c: 0028FF38

We can see that because member b of the structure requires 4-byte alignment, the compiler allocates 3 bytes after allocating space to member a, and only allocates storage space to member b at the 0x0028FF34 address that satisfies the 4-byte alignment. Next, the member c of type short occupies 2 bytes of storage space. The three structure members occupy a total of 4 "4" 2 "10 bytes of storage space. According to the alignment rules of the structure, the overall alignment of the structure should be aligned to the maximum number of aligned bytes of all members of the structure or their integer multiples, or the overall length of the structure should be an integer multiple of the maximum number of member bytes, if not an integer multiple. Because the largest member of the structure, int, is 4 bytes, or aligned by an integer multiple of 4 bytes, the length of the structure should be an integral multiple of 4, and 2 bytes should be added at the end of the structure, so the size of the final structure is 12 bytes.

Among the members of the structure, different discharge order may also lead to different overall length of the structure. Let's modify the above program.

Struct data {char a; short b; int c;}; int main (void) {struct data s; printf ("size:% d\ n", sizeof (s)); printf ("& s.a:% p\ n", & s.a); printf ("& s.b:% p\ n", & s.b); printf ("& s.c:% p\ n", & s.c);}

The running result of the program is as follows.

Size: 8 & s.a: 0028FF30 & s.b: 0028FF32 & s.c: 0028FF34

We adjusted the order of some members, and you will find that the char variable an and the short variable b are allocated in the first four bytes of the structure, and both satisfy their respective address alignment, and the whole structure size is 8 bytes, resulting in only one byte of memory hole. Let's continue to modify the program so that the short variable b is aligned to 4 bytes:

Struct data {char a; short b _ attribute__ ((aligned (4); int c;}

The running result of the program is as follows.

Size: 12 & s.a: 0028FF30 & s.b: 0028FF34 & s.c: 0028FF38

You will find that the size of the structure has changed back to 12 bytes. This is because we explicitly specify that the short variable is aligned with a 4-byte address, causing the variable a to be filled with 3 bytes of space. The int variable c is also 4-byte aligned, so the variable b is also filled with 2 bytes, resulting in a 12-byte size of the entire structure.

We can explicitly specify not only the address alignment of a member in the structure, but also the alignment of the entire structure.

Struct data {char a; short b; int c;} _ attribute__ ((aligned (16)

The running result of the program is as follows.

Size: 16 & s.a: 0028FF30 & s.b: 0028FF32 & s.c: 0028FF34

In this structure, each member occupies a total of 8 bytes. From the previous study, we know that the alignment of the entire structure can be as long as it is an integral multiple of the number of bytes of maximum member alignment. So the structure as a whole is aligned with 8 bytes, and the overall length of the structure is 8 bytes. But here, we explicitly specify that the structure as a whole is aligned with 16 bytes, so the compiler fills 8 bytes at the end of the structure to meet the requirement of 16-byte alignment, causing the total length of the structure to become 16 bytes.

7.3 think: will the compiler be aligned to the size we specify?

With the aligned attribute, we can explicitly specify the alignment of a variable, so will the compiler necessarily align to the size we specify? No!

By declaring this property, we only recommend that the compiler align at this size, but not more than the maximum allowed by the compiler. A compiler has a default maximum number of boundary-aligned bytes for each basic data type. If you exceed, I'm sorry, I won't accompany you. The compiler can only assign addresses to your variables according to its maximum alignment.

Char C1 = 3; char c2 _ attribute__ ((aligned (16) = 4; int main (void) {printf ("C1 aligned% p\ n", & C1); printf ("c2attribute__% p\ n", & c2); return 0;}

In this program, we specify that the char variable c2 is aligned to 16 bytes, and then run the result as follows:

C1:00402000c2:00402010

We can see that the address assigned to c2 by the compiler is 16-byte address alignment. if we continue to modify c2 variable alignment to 32 bytes, you will find that the running result of the program will no longer change. The compiler will also assign a 16-byte address because it has exceeded the maximum value allowed by the compiler.

Attribute declaration: packed

The aligned attribute is generally used to increase the address alignment of variables, and there is a certain memory hole between elements because of address alignment. The packed attribute, by contrast, is used to reduce address alignment and to specify that variables or types use the smallest possible address alignment.

Struct data {char a; short b _ attribute__ ((packed)); int c _ attribute__ ((packed)); int main (void) {struct data s; printf ("size:% d\ n", sizeof (s)); printf ("& s.a:% p\ n", & s.a); printf ("& s.b:% p\ n", & s.b) Printf (& s.c:% p\ n ", & s.c);}

In this program, we declare the members b and c of the structure using the packed attribute, which tells the compiler to assign addresses to them with the smallest possible address alignment and minimize memory holes. The running result of the program is as follows.

Size: 7 & s.a: 0028FF30 & s.b: 0028FF31 & s.c: 0028FF33

From the results, we can see that the allocation of each member address in the structure uses a minimum alignment of 1 byte, resulting in a size of only 7 bytes of the whole structure.

This feature is also very useful in underlying driver development. For example, you want to define a structure that encapsulates various registers of an IP controller. In the ARM chip, the register address space of each controller is generally continuous. If you consider data alignment, there is a hole in the structure, which is inconsistent with the actual continuous register address. Using packed can avoid this problem. Each member of the structure is assigned a storage address next to each other, thus avoiding the memory hole caused by the address alignment of each member element.

Struct data {char a; short b; int c;} _ attribute__ ((packed))

Adding the packed attribute to the entire structure is the same as adding the packed attribute to each member separately. After modifying the structure, the running result of the program is the same as that of the above program-the size of the structure is 7, and the addresses of the members in the structure are the same.

Declaration of aligned and packed attributes in 7.5 Linux kernel

In the Linux kernel, we often see aligned and packed used together, that is, both aligned and packed attribute declarations are used for a variable or type. The advantage of this is that it not only avoids the memory holes caused by address alignment in the structure, but also specifies the alignment of the entire structure.

Struct data {char a; short b; int c;} _ attribute__ ((packed,aligned (8); int main (void) {struct data s; printf ("size:% d\ n", sizeof (s)); printf ("& s.a:% p\ n", & s.a); printf ("& s.b:% p\ n", & s.b) Printf (& s.c:% p\ n ", & s.c);}

The running result of the program is as follows.

Size: 8 & s.a: 0028FF30 & s.b: 0028FF31 & s.c: 0028FF33

In this program, although the structure data uses the packed attribute to declare that the entire length becomes 7, but we also use aligned (8) to specify that it is aligned by 8-byte address, so the compiler has to fill 1 byte behind the structure, so that the size of the whole structure becomes 8-byte, aligned by 8-byte address.

This tutorial is adapted from the C language embedded Linux Advanced programming Video tutorial No. 05, the electronic version of the book can join the QQ group: 475504428 download, more embedded video tutorials, you can follow:

Official account of Wechat: Otaku tribe (armlinuxfun)

51CTO College-Mr. Wang Litao: http://edu.51cto.com/sd/d344f

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.