Xathrya Sabertooth |
| Disable Automatic Address Configuration – Automatic Private IP Addressing (APIPA) Posted: 16 Dec 2013 10:48 PM PST In every Windows Operating System enabled computer, there is a feature Microsoft offers which is APIPA. APIPA is a DHCP failover mechanism for local networks. With APIPA, DHCP clients can obtain IP addresses when DHCP servers are non-functional or the client couldn’t get the IP from server. APIPA exists in all modern versions of Windows except Windows NT. When DHCP server fails, APIPA allocates IP addresses in the private range 169.254.0.1 to 169.254.255.254. This range is one of Private Network address (hence the name is Automatic Private IP Address). The method is tested on Windows 8.1 64 bit. The method is generic one, using configuration of Registry entry. To do, open registry edition. Before we proceed, please remember that incorrectly editing the registry may severely damage system. You can backup any valued data on your machine before making changes to the registry. You can also use the Last Know Good Configuration startup option if problems are encountered after done this guide. On Windows Vista onward, you will face User Access Control which ask you whether you grant permission for Registry Editor. Choose yes to proceed. In Registry Editor, navigate to the following registry key: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters Now create a DWORD value (32 bit if there is both 32 and 64 bit DWORD value) with following name: IPAutoconfigurationEnabled Set the value to 0. Close the Registry Editor. To make a change, restart the machine. |
| Data Structure Alignment in C++ on x86 and x64 Machine Posted: 16 Dec 2013 10:36 PM PST Data structure alignment is the way data is arranged and accessed in memory. It consists of two separate but related issues: data alignment and data structure padding. In this article we will discuss about memory alignment for simple struct. All of the codes are tested on Windows 8 64-bit using GCC compiler suite. OK, I said I use 64-bit Windows 8, but the title suggest we discuss both 32 and 64 bit, therefore I will also give both code. Before we start, guess what the output of this program is? Write down your answer, don’t compile it yet. #include <iostream> using namespace std; // Alignment requirements // char 1 byte // short int 2 bytes // int 4 bytes // double 8 bytes struct A { char c; short s; }; struct B { short s; char c; int i; }; struct C { char c; double d; int i; }; struct D { double d; int i; char c; }; int main() { cout << "The sizeof A is: " << sizeof(A) << endl; cout << "The sizeof B is: " << sizeof(B) << endl; cout << "The sizeof C is: " << sizeof(C) << endl; cout << "The sizeof D is: " << sizeof(D) << endl; return 0; } Now read this article. Definition of Data AlignmentEvery data type in C/C++ will have data alignment requirement (in fact, it is mandated by processor architecture, not by language).
Memory is byte addressable and arranged sequentially. If the memory is arranged as single bank of one byte width, the processor needs to issue 4 memory read cycles to fetch an integer. We can save lot of work when we read all 4 bytes of integer in one memory cycle only. To take such advantage, the memory will be arranged as group of 4 banks. The memory addressing still be sequential. If bank 0 occupies an address X, bank 1, bank 2 and bank 3 will be at (X + 1), (X + 2) and (X + 3) addresses. If an integer of 4 bytes is allocated on X address (X is multiple of 4), the processor needs only one memory cycle to read entire integer. Where as, if the integer is allocated at an address other than multiple of 4, it spans across two rows of the banks. Such an integer requires two memory read cycle to fetch the data.
A variable's data alignment deals with the way the data stored in these banks. It is expressed as the numeric address module of power of 2. For example, the address 0x0001103F modulo 4 is 3; that address is said to be aligned to 4n+3, where 4 indicates the chosen power of 2. The alignment of an address depends on the chosen power of two. The same address modulo 8 is 7. The natural alignment of int on 32-bit machine is 4 bytes. When a data type is naturally aligned, the CPU fetches it in minimum read cycles. Similarly, the natural alignment of several data type are listed here: For 32-bit x86:
A notable difference in alignment for 64-bit system when compared to 32-bit system:
So it means, a short int can be stored in bank 0 – bank 1 pair or bank 2 – bank 3 pair. A double requires 8 bytes, and occupies two rows in the memory banks. Any misalignment of double will force more than two read cycles to fetch double data. As seen before, double variable will be allocated on 8 byte boundary on 32 bit machine and requires two memory read cycles. On a 64 bit machine, based on number of banks, double variable will be allocated on 8 byte boundary and requires only one memory read cycle. So, we can formulate that a memory address A, is said to be N-byte aligned when A is a multiple of N bytes (where N is power of 2). A memory access is said to be aligned when the datum being accessed is N bytes long and the datum address is N-byte aligned. When a memory access is not aligned, it is said to be misaligned. Note that by definition byte memory accesses are always aligned. Structure and Padding to Align the DataIn C/C++, structures are used as a data pack (composite data). It doesn’t provide any data encapsulation or data hiding features (except when we define it with the way we define a class). As stated before, a good aligned data in memory can ease the fetch process. Because of the alignment requirements of various data types, every member of structure should be naturally aligned. The members of structures allocated sequentially increasing order. Now, alignment should be used to balance the structure. The term balance here refer to make every member naturally aligned (remember, short int use 2 bytes and can be put on a pair of byte 0-byte 1 or byte 2-byte 3 but not byte 1-byte 2). Therefore we need to do something to make them in correct position (align). The method we use is padding. Padding is only inserted when a structure member is followed by a member with a larger alignment requirement or at the end of the structure. There is an alternative way, reordering the members, however C/C++ do not allow the compiler to reorder structure members to save space. This job should be done manually. So how this stuff works? Remember, we cannot say that the aggregate size of a struct is only sum of all the components. There exists a padding. The padding boundary also depend on the 32-bit or 64-bit architecture of the CPU and the OS. The alignment is done on the basis of the highest size of the variable in the structure. Let’s view this little structure. When we count it, we should get 8 bytes as total size: struct Mix { char Data1; short Data2; int Data3; char Data4; }; After compilation, appropriate paddings will be inserted to ensure a proper alignment for each of its member: struct Mix { char Data1; // 1 byte char Padding1[1]; short Data2; // 2 bytes int Data3; // 4 bytes char Data4; // 1 byte char Padding2[3]; }; We see two padding there, Padding1 and Padding2. Remember that short require 2-bytes alignment. Hence, it cannot be placed right after Data1, because it would be put on Bank 1-Bank 2 pair. We add padding between them so when we fetch the Data2 we will have minimum fetch. After the Data4, there is also a padding with 3 bytes at the end. Now the compiled size of the structure is 12 bytes. It is important to note that the last member is padded with the number of bytes required so that the total size of the structure should be a multiple of the largest alignment of any structure member (alignment(int) in this case, which = 4 Let’s review the output for previous snippet. If you are confused, first refer to the previous section (Data Alignment) For 64-bit OS user:
For 32-bit Windows user:
For 32-bit Linux user:
You can also prove it by yourself. How do we get that? Structure Astruct A { char c; short s; }; We have two members here, c as character, and s as short integer. Char is 1 byte and Short is 2 bytes. The total should be 3, but it’s 4. If the short int element is immediately allocated after the char element, it will start at an odd address boundary. Therefore a padding is inserted there so now the structure will be: struct A { char c; char Padding; short s; }; And the total sizeof(A) = sizeof(char) + 1 (padding) + sizeof(short) = 1 + 1 + 2 = 4 bytes. Structure Bstruct B { short s; char c; int i; }; We have three members here, s as short integer, c as character, and i as integer. Char is 1 byte, Short is 2 bytes, and Integer is 4 bytes. The total should be 7, but it’s 8. It has the same reason as first example. As i is immediately after c, it will start at an odd address boundary. Therefore a padding is inserted. Now the structure will be: struct B { short s; char c; char Padding; int i; };And the total sizeof(B) = sizeof(short) + sizeof(char) + 1 (padding) + sizeof(int) = 2 + 1 + 1 + 4 = 8 bytes. Structure Cstruct C { char c; double d; int i; };Now this is the trickiest part. We have three members here, c as character, d as double float, and i as integer. If your architecture is 64-bit, you get Double as 8 bytes while 32 you get 4 bytes. Other than those, all other value is remain same. Char is 1 byte, and Integer is 4 bytes. The total should be 7, but it’s 8. Now, the after compilation for x64 we got: struct C { char c; // 1 byte char Padding1[7]; double d; // 8 bytes int i; // 4 bytes char Padding2[4]; }; So you would wonder, why the padding Padding1 is 7 bytes instead of 3 bytes? Remember that the boundary is determined by the largest element’s boundary. We have double which is 8 bytes. So the total size would be: sizeof(C) = sizeof(char) + 7 (padding) + sizeof(double) + sizeof(int) + 4 (padding) = 1 + 7 + 8 + 4 + 4 = 24 Now we see for the x86 Linux (gcc) case: struct C { char c; // 1 byte char Padding1[3]; double d; // 4 bytes int i; // 4 bytes char Padding2[4]; }; Here we have double as 4 bytes. As very same argument, we insert padding between c and d. There is padding at the end to meet natural alignment so it fit power of 2 size. So the total size would be: sizeof(C) = sizeof(char) + 3 (padding) + sizeof(double) + sizeof(int) + 4 (padding) = 1 + 3 + 4 + 4 + 4 = 16 Structure Dstruct D { double d; int i; char c; }; We still have three members here, d as double, i as integer, and c as character. Char is 1 byte, double is 8 bytes or 4 bytes depend on which system you are (see previous explanation), and Integer is 4 bytes. Both 64 and 32 bit will have following alignment after compilation: struct D { double d; // 8 bytes int i; // 4 bytes char c; // 1 byte char Padding1[3]; }; So you might expect, the padding is 3 byte at the end of struct so we can’t ensure the size is natural aligned. So the total size would be: sizeof(D) = sizeof(double) + sizeof(int) + sizeof(char) + 3 (padding) = 8 + 4 + 1 + 3 = 16 |
| You are subscribed to email updates from Xathrya Sabertooth To stop receiving these emails, you may unsubscribe now. | Email delivery powered by Google |
| Google Inc., 20 West Kinzie, Chicago IL USA 60610 | |
