Est-ce que ma machine AMD utilise peu endian ou big endian?

Question

Je vais bien un cours de système informatique et j'essaie d'établir, pour sûr, si mon ordinateur basé sur AMD est une petite machine d'endian? Je crois que c'est parce que ce serait compatible avec Intel. En particulier, mon processeur est un AMD 64 Athlon x2. Je comprends que cela peut avoir de l'importance dans la programmation en langage C (C12). J'écris des programmes C et une méthode que j'utilise serait affectée par cela. J'essaye de comprendre si j'obtiendrais les mêmes résultats si j'ai couru le programme sur une machine basée d'Intel (en supposant que est petite machine d'endian). Enfin, permettez-moi de vous poser une question: est-ce que toutes les machines capables de fonctionner sous Windows (XP, Vista, 2000, Server 2003, etc) et, disons, Ubuntu Linux desktop seraient peu endian?

Merci,
Frank

Answer 1

Tous x86 et x86-64 machines (qui est juste une extension x86) sont peu endian.

Vous pouvez le confirmer avec quelque chose comme ceci:

#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; 
} 

Answer 2

En réponse à votre dernière question, la réponse est non. Linux est capable de fonctionner sur de grosses machines endian comme, par exemple, les PowerMacs de génération antérieure.

Answer 3

Vous devez télécharger une version d'Ubuntu conçue pour les grosses machines. Je ne connais que les versions PowerPC. Je suis sûr que vous pouvez trouver une place qui a une implémentation big-endian plus générique.

Answer 4

Un moyen facile de connaître les ENDIANNESS est listé dans l'article Writing endian-independent code in C

const int i = 1; 
#define is_bigendian() ((*(char*)&i) == 0) 

Answer 5

« Intel compatible » n'est pas très précis.

Intel fabriquait des processeurs big-endian, notamment le StrongARM et le XScale. Ils n'utilisent pas l'ISA IA32, communément appelé x86. Plus loin dans l'histoire, Intel a également fait le petit-boutiste i860 et i960, qui ne sont pas non plus compatibles x86. Plus loin dans l'histoire, les précurseurs du x86 (8080, 8008, etc.) ne sont pas non plus compatibles x86. Étant des processeurs 8 bits, l'endianness n'a pas vraiment d'importance ...

De nos jours, Intel fabrique toujours le Itanium (IA64), qui est bi-endian: le fonctionnement normal est big-endian, mais le processeur peut également fonctionner dans mode little-endian. Il arrive d'être capable d'exécuter du code x86 en mode little-endian, mais l'ISA natif n'est pas IA32. A ma connaissance, tous les processeurs AMD ont été compatibles x86, avec certaines extensions comme x86_64, et sont donc forcément little-endian. Ubuntu est disponible pour x86 (little-endian) et x86_64 (little-endian), avec des ports moins complets pour ia64 (big-endian), ARM (el) (little-endian), PA-RISC (big- endian, bien que le processeur supporte à la fois), PowerPC (big-endian), et SPARC (big-endian). Je ne crois pas qu'il existe un port ARM (eb) (big-endian).

Answer 6

En supposant que vous avez Python installé, vous pouvez exécuter ce one-liner, qui imprime "peu" sur des machines peu endian et "grand" sur les grands-endian:

python -c "import struct; print 'little' if ord(struct.pack('L', 1)[0]) else 'big'" 

Answer 7

Endianness Livre blanc de Intel Corp publié le 15 Novembre, 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 

Answer 8

/* by Linas Samusas */ 

#ifndef _bitorder 
#define _bitorder 0x0008 

#if (_bitorder > 8) 
#define BE 
#else 
#define LE 
#endif 

et utiliser cette

#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 appellera fonction réelle et il convertissent l'

si BE

unsigned long number1 = Function_Convert_to_be_16(number2); 

* macro sera défini comme mot pas une fonction et votre numéro sera entre parenthèses