hexadecimal - ¿Mi máquina basada en AMD usa little endian o big endian?
little endian and big endian pdf (8)
Estoy yendo a un curso de computación y estoy tratando de establecer, de seguro , si mi computadora basada en AMD es una pequeña máquina endian. Creo que es porque sería compatible con Intel.
Específicamente, mi procesador es un AMD 64 Athlon x2.
Entiendo que esto puede importar en la programación de C. Estoy escribiendo C programas y un método que estoy usando se vería afectado por esto. Estoy tratando de averiguar si obtendría los mismos resultados si ejecutara el programa en una máquina basada en Intel (suponiendo que sea una pequeña máquina endian).
Finalmente, permítanme preguntarles: ¿Serán todas las máquinas capaces de ejecutar Windows (XP, Vista, 2000, Server 2003, etc.) y, digamos, Ubuntu Linux de escritorio, poco endian?
Gracias,
Franco
"Intel compatible" no es muy preciso.
Intel solía hacer procesadores big-endian, en particular el StrongARM y XScale. Estos no usan IA32 ISA, comúnmente conocido como x86.
Más atrás en la historia, Intel también fabricó el i-end i860 e i960, que tampoco son compatibles con x86.
Más atrás en la historia, los precursores del x86 (8080, 8008, etc.) tampoco son compatibles con x86. Al ser procesadores de 8 bits, el endianness realmente no importa ...
Hoy en día, Intel todavía fabrica el Itanium (IA64), que es bi-endian: el funcionamiento normal es big-endian, pero el procesador también se puede ejecutar en modo little-endian. Resulta ser capaz de ejecutar código x86 en modo little-endian, pero el ISA nativo no es IA32.
Que yo sepa, todos los procesadores de AMD han sido compatibles con x86, con algunas extensiones como x86_64, y por lo tanto son necesariamente poco endian.
Ubuntu está disponible para x86 (little-endian) y x86_64 (little-endian), con puertos menos completos para ia64 (big-endian), ARM (el) (little-endian), PA-RISC (big-endian, aunque el el procesador admite ambos), PowerPC (big-endian) y SPARC (big-endian). No creo que haya un puerto ARM (eb) (big-endian).
Asumiendo que tiene instalado Python, puede ejecutar este one-liner, que imprimirá "poco" en máquinas little-endian y "big" en big-endian:
python -c "import struct; print ''little'' if ord(struct.pack(''L'', 1)[0]) else ''big''"
Documento técnico de Endianness de Intel Corp publicado el 15 de noviembre de 2004 http://www.intel.com/design/intarch/papers/endian.pdf
Contents ========= Introduction .................................................5 Analysis .................................................5 Code Portability .........................................5 Shared Data ..............................................5 Best Known Methods .......................................5 Definition of Endianness .....................................5 Merits of Endian Architectures ...............................6 Relevance of Endian Order ................................7 Byte Swapping ................................................8 Byte Swapping Methods ....................................8 Network I/O Macros ...................................8 Custom Byte Swap Macros ..............................9 Byte Swap Controls .......................................9 Compile Time Controls ...............................10 Run Time Controls ...................................10 Recovering Byte Swap Overhead ...........................11 Platform Porting Considerations .............................11 Data Storage and Shared Memory ..........................11 Data Transfer ...........................................12 Data Types ..............................................12 Unions ..............................................12 Byte Arrays .........................................12 Bit Fields and Bit Masks ............................12 Pointer Casts .......................................13 Native Data Types .......................................14 Endian-Neutral Code .........................................14 Guidelines for Implementing Endian-neutral Code .............15 Endian-neutral Coding Practices .........................15 Code Analysis ...........................................15 The Good ............................................16 The Bad .............................................16 The Ugly ............................................16 Converting Endian-specific to Endian-neutral Code ...........16 Reversing Endian-specific Architecture of Code ..............16 Conclusion ..................................................17
En respuesta a su pregunta final, la respuesta es no. Linux es capaz de ejecutarse en máquinas big endian como, por ejemplo, la generación anterior de PowerMacs.
Tienes que descargar una versión de Ubuntu diseñada para máquinas big endian. Sólo sé de las versiones de PowerPC . Estoy seguro de que puedes encontrar algún lugar que tenga una implementación de big-endian más genérica.
Todas las máquinas x86 y x86-64 (que es solo una extensión de x86) son little-endian.
Puedes confirmarlo con algo como esto:
#include <stdio.h>
int main() {
int a = 0x12345678;
unsigned char *c = (unsigned char*)(&a);
if (*c == 0x78) {
printf("little-endian/n");
} else {
printf("big-endian/n");
}
return 0;
}
Una forma fácil de conocer las endiannes se encuentra en el artículo Cómo escribir código independiente de endian en C
const int i = 1;
#define is_bigendian() ( (*(char*)&i) == 0 )
/* by Linas Samusas */
#ifndef _bitorder
#define _bitorder 0x0008
#if (_bitorder > 8)
#define BE
#else
#define LE
#endif
y usa esto
#ifdef LE
#define Function_Convert_to_be_16(value) real_function_to_be_16(value)
#define Function_Convert_to_be_32(value) real_function_to_be_32(value)
#define Function_Convert_to_be_64(value) real_function_to_be_64(value)
#else
#define Function_Convert_to_be_16
#define Function_Convert_to_be_32
#define Function_Convert_to_be_64
#endif
si LE
unsigned long number1 = Function_Convert_to_be_16(number2);
* macro llamará a la función real y se convertirá en BE
si BE
unsigned long number1 = Function_Convert_to_be_16(number2);
* la macro se definirá como una palabra y no una función y su número estará entre paréntesis