Conclusion | Computer Architecture | city university of seattle
Abstract
Computers speak different languages, like people. Some write data “left-to-right” and others “right-to-left”. If a machine can read its own data it tends to encounter no problems but when one computer stores data and a different type tries to read it, that is when a problem occurs. This document aims to present how Endianness is willing to be taken into consideration how Endian specific system inter-operate sharing data without misinterpretation of the value. Endianness describes the location of the most significant byte (MSB) and least significant byte (LSB) of an address in memory and is defined by the CPU architecture implementation of the system. Unfortunately, not all computer systems are designed with constant Endian architecture. The difference in Endian architecture is a difficulty when software or data is shared between computer systems. Little and big endian are two ways of storing multibyte data- type (int, float, etc.). In little endian machines, last byte of binary representation of the multi byte data- type is stored first. On the opposite hand, in big endian machines, first byte of binary representation of the multi byte datatype is stored first. Suppose we write float value to a file on a little-endian machine and transfer this file to a big-endian machine. Unless there is correct transformation, big endian machine will read the file in reverse order. This paper targets on showcasing how CPU-based Endianness raises software issues when reading and writing the data from memory. We will try to reinterpret this information at register/system-level.
Keywords: –
endianness, big-endian, little-endian, most significant byte (MSB), least significant byte (LSB).
Definition of Endianness: –
Endianness refers to order of bits or bytes within a binary representation of a number. All computers do not store multi-byte value in the same order. The difference in Endian architecture is an issue when software or data is shared between computer systems. An analysis of the computer system and its interfaces will determine the requirements of the Endian implementation of the software. Based on which value is stored first, Endianness can be either big or small, with the adjectives referring to which value is stored first.
Little Endian and Big Endian: –
Endianness illustrates how a 32-bit pattern is held in the four bytes of memory. There are 32 bits in four bytes and 32 bits in the pattern, but a choice has to be made about which byte of memory gets what part of the pattern. There are two ways that computers commonly do this.
Little endian and Big endian are the two ways of storing multibyte data types. Little Endian and Big Endian are also called host byte order and network byte order respectively. In a multibyte data type, right most byte is called least significant byte (LSB) and left most byte is called most significant byte (MSB). In little endian the least significant byte is stored first, while in big endian, most significant byte is stored. For example, if we have store 0x01234567, then big and little endian will be stored as below:
However, within a byte the order of the bits is the same for all computers, no matter how the bytes themselves are arranged.
Bi -Endian: –
Some architectures such as ARM versions 3 and above, MIPS, PA-RISC, etc. feature a setting which allows for switchable endianness in data fetches and stores, instruction fetches, or both. This feature can improve performance or simplify the logic of networking devices and software. The word bi-endian, when said of hardware, denotes the capability of the machine to compute or pass data in either endian format.
Importance of endianness:
Endianness is the attribute of a system that indicates whether the data type like integer values are represented from left to right or vice-versa. Endianness must be chosen every time hardware or software is designed.
When Endianness affects code:
Endianness doesn’t apply to everything. If you do bitwise or bit-shift operations on an int, you don’t notice endianness. However, when data from one computer is used on another you need to be concerned. For example, you have a file of integer data that was written by another computer. To read it correctly, you need to know:
· The number of bits used to represent each integer.
· The representational scheme used to represent integers (two’s complement or other).
· Which byte ordering (little or big endian) was used.
Processors Endianness:
CPU controls the endianness. A CPU is instructed at boot time to order memory as either big or little endian A few CPUs can switch between big-endian and little-endian. However, x86/amd64 architectures don’t possess this feature. Computer processors store data in either large (big) or small (little) endian format depending on the CPU processor architecture. The Operating System (OS) does not factor into the endianness of the system, rather the endian model of the CPU architecture dictates how the operating system is implemented. Big endian byte ordering is considered the standard or neutral “Network Byte Order”. Big endian byte ordering is in a suitable format for human interpretation and is also the order most often presented by hex calculators. As most embedded communication processors and custom solutions associated with the data plane are Big-Endian (i.e. PowerPC, SPARC, etc.), the legacy code on these processors is often written specifically for network byte order (Big-Endian).
Few of the processors with their respective endianness’s are listed below: –
Processor
Endianness
Motorola 68000
Big Endian
PowerPC (PPC)
Big Endian
Sun Sparc
Big Endian
IBM S/390
Big Endian
Intel x86 (32 bit)
Little Endian
Intel x86_64 (64 bit)
Little Endian
Dec VAX
Little Endian
Alpha
Bi (Big/Little) Endian
ARM
Bi (Big/Little) Endian
IA-64 (64 bit)
Bi (Big/Little) Endian
MIPS
Bi (Big/Little) Endian
Bi-Endian processors can be run in either mode, but only one mode can be chosen for operation, there is no bi-endian byte order. Byte order is either big or little endian.
Performance analysis:
Endianness refers to data types that are stored differently in memory, which means there are considerations when accessing individual byte locations of a multi-byte data element in memory.
Little-endian processors have an advantage in cases where the memory bandwidth is limited, like in some 32-bit ARM processors with 16-bit memory bus, or the 8088 with 8-bit data bus. The processor can just load the low half and complete add/sub/multiplication with it while waiting for the higher half. With big-endian order when we increase a numeric value, we add digits to the left (a higher non-exponential number has more digits). Thus, an addition of two numbers often requires moving all the digits of a big-endian ordered number in storage, to the right. However, in a number stored in little-endian fashion, the least significant bytes can stay where they are, and new digits can be added to the right at a higher address. Thus, resulting in some simpler and faster computer operation.
Similarly, when we add or subtract multi-byte numbers, we need to start with the least significant byte. If we are adding two 16-bit numbers, there may be a carry from the least significant byte to the most significant byte, so we must start with the least significant byte to see if there is a carry. Therefore, we start with the rightmost digit when doing longhand addition and not from left. For example, consider an 8-bit system that fetches bytes sequentially from memory. If it fetches the least significant byte first, it can start doing the addition while the most significant byte is being fetched from memory. This parallelism is why performance is better in little endian on such as system. In case, it had to wait until both bytes were fetched from memory, or fetch them in the reverse order, it would take longer.
In “Big-Endian” processor, by having the high-order byte come first, we can quickly analyze whether a number is positive or negative just by looking at the byte at offset zero. We don’t have to know how long the number is, nor do you have to skip over any bytes to find the byte containing the sign information. The numbers are also stored in the order in which they are printed out, so binary to decimal routines are highly efficient.
Handling endianness automatically:-
To work automatically, network stacks and communication protocols must also define their endianness, otherwise, two nodes of different endianness won’t be able to communicate. Such a concept is termed as “Network Byte Order”. All protocol layers in TCP/IP are defined to be big endian which is typically called network byte order and that they send and receive the most significant byte first.
If the computers at each end are little-endian, multi-byte integers passed between them must be converted to network byte order before transmission, across the network and converted back to little-endian at the receiving end.
If the stack runs on a little-endian processor, it’s to reorder, at run time, the bytes of each multi-byte data field within the various headers of the layers. If the stack runs on a big-endian processor, there’s nothing to stress about. For the stack to be portable, it’s to choose to try and do this reordering, typically at compile time.
To convert these conversions, sockets provides a collection of macros to host a network byte order, as shown below:
• htons() – Host to network short, reorder the bytes of a 16-bit unsigned value from processor order to network order.
• htonl() – Host to network long, reorder the bytes of a 32-bit unsigned value from processor order to network order.
• ntohs() – Network to host short, reorder the bytes of a 16-bit unsigned value from network order to processor order.
• ntohl() – Network to host long, reorder the bytes of a 32-bit unsigned value from network order to processor order.
Let’s understand this with a better example:
Suppose there are two machines S1 and S2, S1 and S2 are big-endian and little-endian relatively. If S1(BE) wants to send 0x44332211 to S2(LE)
• S1 has the quantity 0x44332211, it’ll store in memory as following sequence 44 33 22 11.
• S1 calls htonl () because the program has been written to be portable. the quantity continues to be represented as 44 33 22 11 and sent over the network.
• S2 receives 44 33 22 11 and calls the ntohl().
• S2 gets the worth represented by 11 22 33 44 from ntohl(), which then results to 0x44332211 as wanted.
