Memory alignment in C Language

1. What is alignment and why:

1. in modern computers, memory space is divided by byte. Theoretically, it seems that access to any type of variables can start from any address, however, the actual situation is that access to specific variables is often performed at specific memory addresses, which requires various types of data to be arranged in space according to certain rules, instead of sequential emissions, this is alignment.

2. Alignment function and cause: Each hardware platform has a big difference in processing the storage space. Some platforms can only access certain types of data from some specific addresses. This may not be the case for other platforms, but the most common problem is that alignment of data storage according to the requirements suitable for their platforms will result in a loss of access efficiency. For example, some platforms start from the even address each time they read data. If an int type (assuming 32-bit) is stored at the beginning of the even address, a read cycle can be read, if the data is stored at the beginning of the odd address, it may take two read cycles and splice the high and low bytes of the two read results to obtain the int data. Obviously, reading efficiency is greatly reduced. This is also a game of space and time.

Ii. Alignment implementation

Usually, we do not need to consider alignment when writing a program. The compiler selects an alignment policy suitable for the target platform for us. Of course, we can also notify the compiler to pass the pre-compilation command to change the Alignment Method for the specified data.
However, because we generally do not need to care about this issue, the editor is aligned with the data storage. If we do not know it, we are often confused about some problems. The most common result is the sizeof result of the struct data structure, which is unexpected. Therefore, we need to understand Alignment Algorithms.
Alignment Algorithm:
The gcc version 3.2.2 Compiler (32-bit x86 Platform) is used as an example, to discuss how the compiler alignment each member in the struct data structure.
The struct is defined as follows:
Struct {
Int;
Char B;
Short c;
};
Struct A contains A four-byte int, A one-byte char, and A two-byte short data. Therefore, the space used by A is 7 bytes. However, the compiler must align the data members in space.
Therefore, the sizeof (strcut A) value is 8.
Now adjust the sequence of the member variables for this struct.
Struct B {
Char B;
Int;
Short c;
};
At this time, it is also a total of 7 bytes of variables, but the value of sizeof (struct B) is 12.
Next we will use the pre-compiled command # pragma pack (value) to tell the compiler to replace the default value with the specified alignment value.
# Progma pack (2)/* specify to align by 2 bytes */
Struct C {
Char B;
Int;
Short c;
};
# Progma pack ()/* cancel the specified alignment and restore the default alignment */
The value of sizeof (struct C) is 8.

Modify the alignment value to 1:
# Progma pack (1)/* specify to align by 1 byte */
Struct D {
Char B;
Int;
Short c;
};
# Progma pack ()/* cancel the specified alignment and restore the default alignment */
The sizeof (struct D) value is 7.

For char data, its own alignment value is 1, for short data is 2, for int, float, double type, its own alignment value is 4, in bytes.
There are four conceptual values:
1) alignment of the Data Type itself: Alignment of the basic data type described above.

2) Specify the alignment value: # specify the alignment value when pragma pack (value) is used.

3) alignment value of a struct or class: The value with the largest alignment value among its members.

4) Valid alignment values of data members, struct, and classes: the alignment value itself and the smaller value in the specified alignment value.

With these values, we can easily discuss the data structure members and their alignment. The valid alignment value N is the final value used to determine the data storage address. Valid alignment means "alignment on N", that is, the "Starting address for storing the data % N = 0 ". data variables in the data structure are discharged in the defined order. The starting address of the first data variable is the starting address of the data structure. The member variables of the struct must be aligned and discharged, and the struct itself must be rounded according to its own valid alignment values (that is, the total length occupied by the member variables of the struct must be several times the effective alignment value of the struct, ). In this way, it is not difficult to understand the values of the above examples.
Example Analysis:
Analysis example B;
Struct B {
Char B;
Int;
Short c;
};
Assume that B is discharged from the address space 0x0000. The alignment value is not defined in this example. In the author's environment, this value is 4 by default. The first member variable B's own alignment value is 1, which is smaller than the specified or default alignment value 4, so its valid alignment value is 1, therefore, the storage address 0x0000 is 0 x 0000% 1 = 0. the alignment value of the second member variable a is 4, so the valid alignment value is 4. Therefore, it can only be stored in the four consecutive bytes from the starting address 0x0004 to 0x0007, review 0 x 0004% 4 = 0, which is close to the first variable. The third variable c has its own alignment value of 2, so the valid alignment value is also 2, which can be stored in the two bytes from 0x0008 to 0x0009, Which is 0 x 0008% 2 = 0. Therefore, B content is stored from 0x0000 to 0x0009. Then, let's look at the alignment value of Data Structure B as the maximum alignment value in its variable (here it is B), so it is 4, so the valid alignment value of the structure is also 4. According to the requirements of the structure, 0x0009 to 0x0000 = 10 bytes, (10 + 2) % 4 = 0. Therefore, 0x0000A to 0x000B is also occupied by struct B. Therefore, B has 12 bytes from 0x0000 to 0x000B, and sizeof (struct B) = 12;

Similarly, analyze the above example C:
# Pragma pack (2)/* specify to align by 2 bytes */
Struct C {
Char B;
Int;
Short c;
};
# Pragma pack ()/* cancel the specified alignment and restore the default alignment */
The first variable B's own alignment value is 1 and the specified alignment value is 2. Therefore, the valid alignment value of B is 1. Suppose C starts from 0x0000, then B is stored in 0x0000, conforms to 0 x 0000% 1 = 0; the second variable, its own alignment value is 4, and the specified alignment value is 2, so the valid alignment value is 2, therefore, the sequence is stored in four consecutive bytes, namely 0x0002, 0x0003, 0x0004, and 0 x 0002%. The alignment value of the third variable c is 2, so the valid alignment value is 2, which is stored in sequence.
In 0x0006, 0x0007, 0 x 0006% 2 = 0. Therefore, from 0x0000 to 0x00007, a total of eight characters are stored in the C variable. And C's own alignment value is 4, so the valid alignment value of C is 2. Again 8% 2 = 0, C only occupies eight bytes from 0x0000 to 0x0007. So sizeof (struct C) = 8.

With the above explanation, I believe you should have a clear understanding of the concept of byte alignment in C language. In network programs, it is very important to master this concept. A binary stream (such as a struct) is transmitted between different platforms (such as between Windows and Linux ), therefore, the same alignment method must be defined between the two platforms. Otherwise, some errors may occur, but it is difficult to troubleshoot.

Companies such as Intel and Microsoft once had a similar interview question:
# Include <iostream. h>
# Pragma pack (8)
Struct example1
{
Short;
Long B;
};
Struct example2
{
Char c;
Example1 struct1;
Short e;
};
# Pragma pack ()
Int main (int argc, char * argv [])
{
Example2 struct2;
Cout <sizeof (example1) <endl;
Cout <sizeof (example2) <endl;
Cout <(unsigned int) (& struct2.struct1)-(unsigned int) (& struct2) <endl;
Return 0;
}
What is the input result of the program?
The answer is:
8
16
4


Answers to interview questions
So far, we can answer Intel and Microsoft interview questions comprehensively.
Line 1 in the Program # pragma pack (8) although the ing is specified as 8, the maximum number of members in struct example1 is
The size is 4 (long variable size is 4), so struct example1 is still bounded by 4 bytes, and the size of struct example1
Is 8, that is, the output result of 18th rows;
Struct example2 contains struct example1. the maximum size of simple data members contained in struct example1 is 2 (short
Variable e), but because it contains struct example1, the maximum member size in struct example1 is 4, struct
Example2 should also be bounded by 4, # The peer bound in pragma pack (8) does not work for struct example2, so 19 rows
The output result is 16;
Since the members in struct example2 are 4-aligned, the char variable c should be followed by three null values, followed
The memory space of the struct1 member. The output result of 20 rows is 4.

Union
{
Int a [5];
Char B;
Double c;
};

Struct B
{
Int n;
A;
Char c [10];
}

Sizeof (B) =?

Answer:

Union:
{
Int a [5]; // 20
Char B; // 1
Double c; // 8
}

What I think is that variables in union share the memory. The longest value shall prevail, that is, 20. Otherwise, sizeof (A) = 24,

The default memory alignment of each variable in A must be aligned with the maximum double 8 bytes, so it should be sizeof (A) = 24.

Struct B
{
Int n; // 4 bytes
A a; // 24 bytes
Char c [10]; // 10 bytes
};
It actually occupies 38 bytes, but since A is 8 bytes aligned, int n and char c [10] also need 8 bytes aligned, A total of 8 + 24 + 16 = 48