Ordine dei byte

L'ordine dei byte (conosciuto anche come big-endian, little-endian o middle-endian a seconda dei metodi differenti), in informatica, indica modalità differenti usate dai calcolatori per immagazzinare in memoria dati di dimensione superiore al byte (es. word, dword, qword).

Storia

La endianness (ordine dei byte) di un computer dipende essenzialmente dall'architettura hardware usata. Ad esempio, Intel e Digital usano il formato little-endian mentre Motorola, IBM e Sun usano il formato big-endian. Il formato dei dati contenuti nelle intestazioni dei protocolli di rete è anch'esso big-endian; altri esempi di uso di questi due diversi formati sono quello del bus PCI, che è little-endian, o quello del bus VME che è big-endian.

Etimologia

I termini big-endian e little-endian derivano dai nomi di due popolazioni che abitavano nelle favolose isole di Lilliput e Blefuscu nel romanzo I viaggi di Gulliver di Jonathan Swift. Queste erano entrate in rivalità per il modo in cui aprivano le uova - rompendo la punta o il fondo: a Lilliput, per editto dell'imperatore il cui figlio una volta si tagliò aprendo un uovo dall'estremità più grande, fu ordinato di aprire le uova dall'estremità più piccola (little endians); a Blefuscu si rifugiarono gli oppositori che volevano conservare la tradizione di rompere le uova dall'estremità più grande (big endians). A causa di questa differenza e della sua legittimazione imperiale era scoppiata tra le due isole una guerra sanguinosa.

Descrizione

Questa differenziazione non riguarda né la posizione dei bit all'interno del byte, nel qual caso si parla di ordine dei bit, né le posizioni dei caratteri in una stringa. Ha invece importanza nell'interpretazione (decodifica) di stringhe multi-byte di caratteri, ad esempio la codifica UTF-16 dello standard unicode.

Classificazione

Thumb — Diagramma che mostra le differenze tra la notazione *little-endian* e quella *big-endian*

La differenza tra i due sistemi è data dall'ordine con cui i byte costituenti il dato da immagazzinare vengono memorizzati o trasmessi:

big-endian: memorizzazione/trasmissione che inizia dal byte più significativo (estremità più grande) per finire col meno significativo, è utilizzata dai processori Motorola;
little-endian: memorizzazione/trasmissione che inizia dal byte meno significativo (estremità più piccola) per finire col più significativo, è utilizzata dai processori Intel;

Nota bene: il termine endian genera spesso confusione; per ricordare correttamente la differenza si rammenti che endian si riferisce alla estremità da cui il dato originale comincia a essere elaborato (scritto/letto su/da memoria o trasmesso/ricevuto su/da canale di comunicazione), non a quale estremità finisce per ultima in memoria o su canale di comunicazione.

L'ordine big-endian è stato scelto come ordine standard in molti protocolli utilizzati in Internet, viene perciò anche chiamato network byte order. Per contro viene chiamato host byte order l'ordine nativo dell'host

Esempi

Nel caso di una WORD (16 bit), il numero esadecimale 0x0123 viene immagazzinato come:

      Little-endian             Big-endian
       +----+----+              +----+----+
       |0x23|0x01|              |0x01|0x23|
       +----+----+              +----+----+
 byte:    0    1                   0    1

Nel caso di una DWORD (32 bit), il numero esadecimale 0x01234567 verrà immagazzinato come:

           Little-endian             Big-endian
       +----+----+----+----+    +----+----+----+----+
       |0x67|0x45|0x23|0x01|    |0x01|0x23|0x45|0x67|
       +----+----+----+----+    +----+----+----+----+
 byte:    0    1    2    3         0    1    2    3

(Negli esempi il valore 0x01 è il byte più significativo)

Funzioni per la conversione

Le seguenti funzioni possono essere usate per convertire da little a big endian e viceversa (la conversione è perfettamente simmetrica).

Implementazione in C

Conversione di word

 unsigned short int Endian_Word_Conversion(unsigned short int word) {
    return ((word>>8)&0x00FF) | ((word<<8)&0xFF00)  ;
 }

Conversione di double word

 unsigned long int Endian_DWord_Conversion(unsigned long int dword) {
    return ((dword>>24)&0x000000FF) | ((dword>>8)&0x0000FF00) | ((dword<<8)&0x00FF0000) | ((dword<<24)&0xFF000000);
 }

Implementazione in C#

UInt32

 public uint Endian_UInt32_Conversion(uint value){
    return ((value >> 24) & 0x000000FF) | ((value >> 8) & 0x0000FF00) | ((value << 8) & 0x00FF0000) | ((value << 24) & 0xFF000000);
 }

UInt64

 public ulong Endian_UInt64_Conversion(ulong value){
    return ((value >> 56) & 0x00000000000000FF) | ((value >> 40) & 0x000000000000FF00) | ((value >> 24) & 0x0000000000FF0000) | ((value >> 8) & 0x00000000FF000000) | ((value << 8) & 0x000000FF00000000) 
 | ((value << 24) & 0x0000FF00000000) | ((value << 40) & 0x00FF0000000000) | ((value << 56) & 0xFF000000000000);
 }

Implementazione in C++

Da C++23 è disponibile std::byteswap.

Uso per i formati di data

I termini vengono alle volte usati^{[senza fonte]} anche per indicare il formato di data:

gg/mm/aaaa: la data europea è little-endian
aaaa/mm/gg: la data big-endian è usata in Giappone e in ISO 8601
mm/gg/aaaa: la data usata in U.S.A. è middle-endian

Voci correlate

Altri progetti

Wikimedia Commons contiene immagini o altri file sull'ordine dei byte

Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica