Exploration of memory alignment Problems

The following are examples of memory alignment.

# Include <iostream>

# Include <cstdio>
Class Test
{

};
Int main ()
{
Int I = sizeof (test );
Printf ("% d", I );
Getchar ();

}

Print result: ::::: it is 1

# Include <iostream>
# Include <cstdio>
Class Test
{
Int;
Char C;

};
Int main ()
{
Int I = sizeof (test );
Printf ("% d", I );
Getchar ();
}

Printed result: 8

# Include <iostream>
# Include <cstdio>
Class Test
{
Int;
Char C;
Char AA;

};
Int main ()
{
Int I = sizeof (test );
Printf ("% d", I );
Getchar ();
}

Printed result: 8

Introduction to byte alignment: What is alignment and why? memory space in modern computers is divided by byte, theoretically, it seems that access to any type of variables can start from any address, but the actual situation is that access to specific variables is often performed at specific memory addresses, in this case, various types of data need to be arranged in space according to certain rules, instead of sequential emissions. This is alignment. Alignment functions and causes: the processing of storage space varies greatly by hardware platform. 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 of their platforms may cause a loss of access efficiency. For example, some platforms start from the even address each time they read data. If an int type (assuming a 32-bit System) 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. Alignment usually does not need to be considered during program writing. 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: defines struct as follows: struct a {int A; char B; short C ;}; struct a contains a four-byte length Int, one-byte char and 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 A; short C ;}; at this time, it is also a total of 7 bytes, but the value of sizeof (struct B) is 12. The following uses the pre-compiled command # progma 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 A; short C ;};# progma pack ()/* cancel the specified alignment, restore the default alignment */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 A; short C ;}; # progma pack () /* cancel the specified alignment and restore the default alignment */sizeof (struct d) value to 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: the alignment of the basic data type described above. 2. Specify the alignment value: # The alignment value specified for progma pack (value. 3. The 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 of the data itself and the value smaller than 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 an integer multiple of the valid alignment values of the struct, ). In this way, you cannot understand the values of the above examples. Example Analysis: Analyze example B; struct B {char B; int A; 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. Therefore, the 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, the above example C: # progma pack (2) is analyzed) /* specify 2-byte alignment */struct c {char B; int A; short C ;};# progma pack ()/* cancel the specified alignment, 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 is 1. Suppose C starts from 0x0000, B is stored in 0x0000, Which is 0 x 0000% 1 = 0. In the second variable, the alignment value is 4 and the alignment value is 2. Therefore, 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 the order of 0x0006 and 0x0007, Which is 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.