Tutti avranno sentito parlare del problema BIG/LITTLE ENDIAN nelle questioni di programmazione dei computer.

I novizi ne avranno sentito parlare, ma non conosco i dettagli della questione.

I programmatori esperti conoscono bene il problema, ma spesso non ricordano, per una particolare macchina o processore, quale delle due modalita' deve essere usata.

Ma andiamo per gradi...

BIG-ENDIAN e LITTLE ENDIAN sono i termini che descrivono l'ordine con cui una macchina immagazzina i byte di una parola a 16 o 32 bits in memoria.

BIG-ENDIAN e' l'ordine per cui (l'indiano piu' grande) la parte piu' significativa va memorizzata per prima (all'indirizzo piu' basso di memoria).

LITTLE-ENDIAN e' l'ordine per cui (l'indiano piu' piccolo) la parte meno significativa va memorizzata per prima (all'indirizzo piu' basso di memoria).

Facciamo un esempio.

Un computer big-endian che debba memorizzare i due byte esadecimali 4F e 52 della word 4F42 a partire dall'indirizzo 1000 scrivera' i dati nel seguente ordine: 4F all'indirizzo 1000 e 52 all'indirizzo 1001.

Un computer little-endin invece scrivera' i dati nel seguente ordine: 52 all'indirizzo 1000 e 4F all'indirizzo 1001.

Qualcuno si domandera': Che c'entrano gli indiani con l'informatica?

Oppure: va beh! Qual'e' il problema?

La storiella degli indiani e' un semplice sistema figurato per ricordare la differenza tra i due metodi.

Tale denominazione poi e' stata adottata universalmente nel linguaggio informatico.

Per i piu' curiosi che non hanno letto il libro di Jonathan Swift "I viaggi di Gulliver" i BIG ENDIANS erano una fazione politica conservatrice che rompeva le uova dalla parte piu' larga del guscio (nella maniera ortodossa), in contrapposizione al re dei Lillipuziani che richiedeva ai suoi sudditi (i LITTLE ENDIANS appunto) di aprire le uova dalla parte piu' stretta.

I computer IBM370, molti RISC e i processori Motorola usano il metodo big-endian.

Se visualizziamo un dump della memoria di un big-endian i dati verranno mostrati nel corretto ordine.

Dell'altro partito politico sono i processori INTEL e i computer DEC Alpha che preferiscono usare l'altro metodo piu' utile quando si trasmettono i dati.

Per convenzione la parte meno significativa di un dato deve essere trasmessa prima.

Il PowerPC puo' funzionare in tutte e due le modalita'.

In definitiva il problema di compatibilita' tra le due fazioni politiche sorge quando idati vengono stampati, oppure trasmessi da un computer ad un altro.

Attenzione al linguaggio C.

Spesso un programma scritto per un tipo di macchina, non funziona correttamente su un'altra a causa della diversita' delle due modalita' operative appena descritte.

Se il vostro programma scambia l'ordine con cui visualizza i dati, oppure due computer hanno problemi di colloquio, adesso sapete perche'.

Il problema si pone anche nei formati dei file piu' comuni:

• Adobe Photoshop -- Big Endian
• BMP (Windows and OS/2 Bitmaps) -- Little Endian
• DXF (AutoCad) -- Variable
• GIF -- Little Endian
• IMG (GEM Raster) -- Big Endian
• JPEG -- Big Endian
• FLI (Autodesk Animator) -- Little Endian
• MacPaint -- Big Endian
• PCX (PC Paintbrush) -- Little Endian
• PostScript -- Not Applicable (text!)
• POV (Persistence of Vision ray-tracer) -- Not Applicable (text!)
• QTM (Quicktime Movies) -- Little Endian (on a Mac!)
• Microsoft RIFF (.WAV & .AVI) -- Both
• Microsoft RTF (Rich Text Format) -- Little Endian
• SGI (Silicon Graphics) -- Big Endian
• Sun Raster -- Big Endian
• TGA (Targa) -- Little Endian
• TIFF -- Both, Endian identifier encoded into file
• WPG (WordPerfect Graphics Metafile) -- Big Endian (on a PC!)
• XWD (X Window Dump) -- Both, Endian identifier encoded into file

Consultare la tabella qui sotto:

Macchina	Endian
Compaq	Little
Cray	Big
IBM	Big
MAC	Big
PC	Little
SGI	Big
Sun	Big
Vax	Little

oppure compilare il seguente programma e vedere il risultato della stampa sul monitor:

/* On some machines the bytes of a multi-byte */
/* variable are arranged in memory with the */
/* highest-order byte first. Sucn machines are */
/* called big-endian machines. The Sun and */
/* Macintosh computers are big-endian machines.*/
/* On other machines, the lowest byte of a */
/* word is put first in the memory. These are */
/* called little-endian machines. Intel and */
/* Sun computers are little-endian machines. */
/* The PowerPC chip can run in either mode. */
/* This affects some programs. I believe */
/* that if you don't use casts (as in this */
/* program) or unions. programs will run the */
/* same on either machine. The following */
/* program illustrates the kind of problem */
/* that may occur. In cryptography we often */
/* use character data in computations and then */
/* after a computation interpret the results */
/* as characters, so we have to watch out for */
/* this situation. WP--7/01 */

#include
void main()
{
long int v = 0, x = 0x41424344, w = 0,
*y, *z;
char *s,
t[5] = {0x41, 0x42, 0x43, 0x44, 0},
u[5] = "ABCD";
/* On a little-endian machine, the low */
/* order bytes are stored at the lowest */
/* addresses, so the bytes of x are stored */
/* 0x44 first and 0x41 last. t and u are */
/* identical. y points to t, and in y, */
/* the lowest order byte will be 0x41, the */
/* highest order byte will be 0x44. */
s = (char *) &x;
y = (long int *) t;
z = (long int *) u;
printf("x=%08x y = %08x z = %08x ", x, *y, *z);
printf("s= %02x %02x %02x %02x ", s[0], s[1], s[2], s[3]);
printf("t= %02x %02x %02x %02x ", t[0], t[1], t[2], t[3]);
printf("u= %02x %02x %02x %02x ", u[0], u[1], u[2], u[3]);
printf("s = %s t = %s u = %s ", s, t, u);
}
/*
Results on my PC, which is little-endian:
x=41424344 y = 44434241 z = 44434241
s= 44 43 42 41
t= 41 42 43 44
u= 41 42 43 44
s = DCBA t = ABCD u = ABCD
Results on a Sun server which is big-endian
x=41424344 y = 41424344 z = 41424344
s= 41 42 43 44
t= 41 42 43 44
u= 41 42 43 44
s = ABCD t = ABCD u = ABCD
*/

Non si finisce mai d'imparare!

Alla prossima...