Ordine dei byte

Da Wikipedia, l'enciclopedia libera.

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

Etimologia[modifica | modifica sorgente]

I termini big-endian e little-endian derivano, come racconta Jonathan Swift nel romanzo I viaggi di Gulliver, dai nomi di due popolazioni che abitavano nelle favolose isole di Lilliput e Blefuscu, che erano entrati in rivalità per il modo in cui aprivano le uova: rompendo la punta (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ù corta: little endians) o il fondo (a Blefuscu, in cui 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.

Caratteristiche[modifica | modifica sorgente]

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 (o decodifica) delle codifiche multi-byte di stringhe di caratteri (ad esempio: la codifica UTF-16 dello standard unicode).

Classificazione[modifica | modifica sorgente]

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

  • big-endian: memorizzazione che inizia dal byte più significativo per finire col meno significativo, è utilizzata dai processori Motorola e nei protocolli usati in Internet;
  • little-endian: memorizzazione che inizia dal byte meno significativo per finire col più significativo, è utilizzata dai processori Intel;
  • middle-endian: ordine dei byte né crescente né decrescente (ad esempio 3412 o 2143).

L'ordine big-endian, che è 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 in uso.

Storia e motivazioni[modifica | modifica sorgente]

La endianness (ordine dei byte) di un computer dipende essenzialmente dalla 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.

Uso dei formati di data[modifica | modifica sorgente]

I termini vengono alle volte usati 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

Esempi[modifica | modifica sorgente]

Nel caso di una WORD (16 bit), il numero esadecimale 0x0123 verrà 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[modifica | modifica sorgente]

Le seguenti funzioni in linguaggio C possono essere usate per convertire una word e una dword da little a big endian e viceversa (la conversione è perfettamente simmetrica)

Conversione di word[modifica | modifica sorgente]

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

Conversione di double word[modifica | modifica sorgente]

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#[modifica | modifica sorgente]

UInt16[modifica | modifica sorgente]

public ushort Endian_UInt16_Conversion(ushort value){
   return (ushort)(((value >> 8) & 0x00FF) | ((value << 8) & 0xFF00));
}

UInt32[modifica | modifica sorgente]

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

UInt64[modifica | modifica sorgente]

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

Voci correlate[modifica | modifica sorgente]

Altri progetti[modifica | modifica sorgente]

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