Apa kelebihan format endian kecil?

Prosesor Intel (dan mungkin beberapa yang lain) menggunakan format endian kecil untuk penyimpanan.

Saya selalu bertanya-tanya mengapa seseorang ingin menyimpan byte dalam urutan terbalik. Apakah format ini memiliki kelebihan dibandingkan format big endian?

Ada beberapa argumen baik, tetapi satu titik adalah bahwa dalam sistem little-endian, alamat nilai yang diberikan dalam memori, diambil sebagai lebar 32, 16, atau 8 bit, adalah sama.

Dengan kata lain, jika Anda memiliki dalam memori nilai dua byte:

0x00f0   16
0x00f1    0

menganggap '16' sebagai nilai 16-bit (c 'singkat' pada sebagian besar sistem 32-bit) atau sebagai nilai 8-bit (umumnya c 'char') hanya mengubah instruksi pengambilan yang Anda gunakan - bukan alamat yang Anda ambil dari.

Pada sistem big-endian, dengan yang diuraikan sebagai:

0x00f0    0
0x00f1   16

Anda perlu menambah pointer dan kemudian melakukan operasi pengambilan yang lebih sempit pada nilai baru.

Jadi, singkatnya, 'pada sistem endian kecil, gips adalah no-op.'

Saya selalu bertanya-tanya mengapa seseorang ingin menyimpan byte dalam urutan terbalik.

Big-endian dan little-endian hanya "tatanan normal" dan "tatanan terbalik" dari perspektif manusia, dan hanya jika semua ini benar ...

1. Anda membaca nilai di layar atau di atas kertas.
2. Anda meletakkan alamat memori yang lebih rendah di sebelah kiri, dan yang lebih tinggi di sebelah kanan.
3. Anda sedang menulis dalam hex, dengan nybble orde tinggi di sebelah kiri, atau biner, dengan bit paling signifikan di sebelah kiri.
4. Anda membaca dari kiri ke kanan.

Itu semua adalah konvensi manusia yang sama sekali tidak penting bagi CPU. Jika Anda mempertahankan # 1 dan # 2, dan membalik # 3, little-endian akan tampak "sangat alami" bagi orang-orang yang membaca bahasa Arab atau Ibrani, yang dituliskan dari kanan ke kiri.

Dan ada konvensi manusia lain yang membuat big-endian yang tampak tidak alami, seperti ...

• Byte "lebih tinggi" (paling signifikan) harus di alamat memori "lebih tinggi".

Kembali ketika saya kebanyakan pemrograman 68K dan PowerPC, saya menganggap big-endian sebagai "benar" dan little-endian menjadi "salah". Tapi karena saya sudah melakukan lebih banyak pekerjaan ARM dan Intel, saya sudah terbiasa dengan little-endian. Itu benar-benar tidak masalah.

OK, inilah alasannya karena saya sudah menjelaskannya kepada saya: Penambahan dan pengurangan

Ketika Anda menambah atau mengurangi angka multi-byte, Anda harus mulai dengan byte paling signifikan. Jika Anda menambahkan dua angka 16-bit misalnya, mungkin ada carry dari byte paling signifikan ke byte paling signifikan, jadi Anda harus mulai dengan byte paling signifikan untuk melihat apakah ada carry. Ini adalah alasan yang sama bahwa Anda mulai dengan digit paling kanan ketika melakukan penambahan dengan tangan. Anda tidak dapat memulai dari kiri.

Pertimbangkan sistem 8-bit yang mengambil byte secara berurutan dari memori. Jika ia mengambil byte paling signifikan pertama , ia dapat mulai melakukan penambahan sementara byte paling signifikan diambil dari memori. Paralelisme ini adalah mengapa kinerja lebih baik di endian kecil seperti pada sistem. Jika harus menunggu sampai kedua byte diambil dari memori, atau mengambilnya dalam urutan terbalik, itu akan memakan waktu lebih lama.

Ini pada sistem 8-bit lama. Pada CPU modern saya ragu urutan byte membuat perbedaan dan kami menggunakan sedikit endian hanya karena alasan historis.

Dengan prosesor 8 bit itu tentu lebih efisien, Anda dapat melakukan operasi 8 atau 16bit tanpa perlu kode yang berbeda dan tanpa perlu buffer nilai-nilai tambahan.

Masih lebih baik untuk beberapa operasi tambahan jika Anda menangani byte pada suatu waktu.

Tetapi tidak ada alasan bahwa big-endian lebih alami - dalam bahasa Inggris Anda menggunakan tiga belas (little endian) dan dua puluh tiga (big endian)

Konvensi tanggal Jepang adalah "big endian" - yyyy / mm / dd. Ini berguna untuk menyortir algoritma, yang dapat menggunakan perbandingan-string sederhana dengan aturan karakter-pertama yang paling signifikan.

Sesuatu yang serupa berlaku untuk angka-angka big-endian yang disimpan dalam catatan bidang-paling-signifikan-pertama. Urutan signifikansi byte dalam bidang cocok dengan signifikansi bidang dalam catatan, sehingga Anda dapat menggunakan memcmpuntuk membandingkan catatan, tidak terlalu peduli apakah Anda membandingkan dua kata panjang, empat kata, atau delapan byte terpisah.

Balik urutan signifikansi bidang dan Anda mendapatkan keuntungan yang sama, tetapi untuk angka little-endian daripada big-endian.

Tentu saja ini memiliki signifikansi praktis yang sangat kecil. Apakah platform Anda big-endian atau little-endian, Anda dapat memesan bidang catatan untuk mengeksploitasi trik ini jika Anda benar-benar perlu. Hanya saja menyebalkan jika Anda perlu menulis kode portabel .

Saya mungkin juga menyertakan tautan ke banding klasik ...

http://tools.ietf.org/rfcmarkup?url=ftp://ftp.rfc-editor.org/in-notes/ien/ien137.txt

SUNTING

Pikiran ekstra. Saya pernah menulis perpustakaan integer besar (untuk melihat apakah saya bisa), dan untuk itu, potongan 32-bit disimpan dalam urutan little-endian, terlepas dari bagaimana platform memesan bit dalam potongan tersebut. Alasannya adalah ...

1. Banyak algoritma yang secara alami mulai bekerja pada hasil yang paling tidak signifikan, dan ingin tujuan tersebut dicocokkan. Sebagai contoh sebagai tambahan, pembawa membawa lebih banyak dan lebih signifikan, sehingga masuk akal untuk memulai pada akhir yang paling tidak signifikan.

2. Menumbuhkan atau mengecilkan nilai hanya berarti menambah / menghapus bongkahan di akhir - tidak perlu menggeser bongkahan ke atas / ke bawah. Menyalin mungkin masih diperlukan karena realokasi memori, tetapi tidak sering.

Ini tidak memiliki relevansi yang jelas dengan prosesor, tentu saja - sampai CPU dibuat dengan dukungan perangkat keras bilangan bulat besar, itu murni hal perpustakaan.

Tidak ada orang lain yang menjawab MENGAPA ini mungkin dilakukan, banyak hal tentang konsekuensi.

Pertimbangkan prosesor 8 bit yang dapat memuat satu byte dari memori dalam siklus clock yang diberikan.

Sekarang, jika Anda ingin memuat nilai 16 bit, ke (katakanlah) satu-satunya register 16 bit yang Anda miliki - yaitu penghitung program, maka cara sederhana untuk melakukannya adalah:

• Muat satu byte dari lokasi pengambilan
• menggeser byte ke kiri 8 tempat
• memori kenaikan mengambil lokasi oleh 1
• memuat byte berikutnya (ke bagian urutan rendah dari register)

hasilnya: Anda hanya perlu menambah lokasi pengambilan, Anda hanya memuat ke bagian urutan rendah dari register yang lebih luas, dan Anda hanya perlu dapat bergeser ke kiri. (Tentu saja, menggeser ke kanan sangat membantu untuk operasi lain sehingga yang satu ini merupakan sedikit tambahan.)

Konsekuensi dari ini adalah bahwa barang 16 bit (byte ganda) disimpan dalam urutan Most..Least. Yaitu, alamat yang lebih kecil memiliki byte paling signifikan - endian begitu besar.

Jika Anda mencoba memuat menggunakan endian kecil, Anda perlu memuat byte ke bagian bawah register lebar Anda, kemudian memuat byte berikutnya ke area pentahapan, menggesernya, dan kemudian memasukkannya ke bagian atas register yang lebih luas. . Atau gunakan pengaturan gating yang lebih kompleks untuk dapat memuat secara selektif ke byte atas atau bawah.

Hasil dari mencoba sedikit endian adalah Anda membutuhkan lebih banyak silikon (sakelar dan gerbang), atau lebih banyak operasi.

Dengan kata lain, dalam hal mendapatkan uang kembali di masa lalu, Anda mendapatkan lebih banyak pukulan untuk sebagian besar kinerja dan area silikon terkecil.

Hari-hari ini, pertimbangan-pertimbangan ini dan cukup banyak tidak relevan, tetapi hal-hal seperti mengisi pipa mungkin masih sedikit masalah besar.

Ketika datang untuk menulis s / w, hidup sering lebih mudah ketika menggunakan pengalamatan endian kecil.

(Dan prosesor big endian cenderung menjadi big endian dalam hal pemesanan byte dan sedikit endian dalam hal bit-in-bytes. Tetapi beberapa prosesor aneh dan akan menggunakan pemesanan bit endian besar serta pemesanan byte. Ini membuat hidup sangat menarik untuk perancang h / w menambahkan periferal yang dipetakan memori tetapi tidak ada konsekuensi lain bagi programmer.)

jimwise membuat poin yang bagus. Ada masalah lain, di little endian Anda dapat melakukan hal berikut:

byte data[4];
int num=0;
for(i=0;i<4;i++)
    num += data[i]<<i*8; 

OR 

num = *(int*)&data; //is interpreted as

mov dword data, num ;or something similar it has been some time

Lebih lurus ke depan untuk programmer yang tidak terpengaruh oleh kerugian nyata dari lokasi yang ditukar dalam memori. Saya pribadi menemukan endian besar untuk menjadi kebalikan dari apa yang alami :). 12 harus disimpan dan ditulis sebagai 21 :)

Saya selalu bertanya-tanya mengapa seseorang ingin menyimpan byte dalam urutan terbalik

Angka desimal ditulis big endian. Juga bagaimana Anda menulisnya dalam bahasa Inggris. Anda mulai dengan digit paling signifikan dan berikutnya paling signifikan ke paling tidak signifikan. misalnya

1234

adalah seribu dua ratus tiga puluh empat.

Inilah cara big endian kadang-kadang disebut tatanan alam.

Dalam endian kecil, jumlah ini adalah satu, dua puluh, tiga ratus empat ribu.

Namun, ketika Anda melakukan aritmatika seperti penjumlahan atau pengurangan, Anda mulai dengan bagian akhir.

  1234
+ 0567
  ====

Anda mulai dengan 4 dan 7, tulis angka terendah dan ingat carry. Kemudian Anda menambahkan 3 dan 6 dll. Untuk menambah, mengurangi atau membandingkan, lebih mudah diterapkan, jika Anda sudah memiliki logika untuk membaca memori secara berurutan, jika angkanya terbalik.

Untuk mendukung big endian dengan cara ini, Anda perlu logika untuk membaca memori secara terbalik, atau Anda memiliki proses RISC yang hanya beroperasi pada register. ;)

Banyak dari desain Intel x86 / Amd x64 adalah historis.

Big-endian berguna untuk beberapa operasi (perbandingan "bignum" pegas dengan panjang oktet yang sama dengan pikiran). Little-endian untuk orang lain (menambahkan dua "bignum", mungkin). Pada akhirnya, itu tergantung pada apa perangkat keras CPU telah diatur, biasanya satu atau yang lain (beberapa chip MIPS, IIRC, switchable saat boot menjadi LE atau BE).

Ketika hanya penyimpanan dan transfer dengan panjang variabel yang terlibat, tetapi tidak ada aritmatika dengan nilai berganda, maka LE biasanya lebih mudah untuk ditulis, sedangkan BE lebih mudah dibaca.

Mari kita ambil konversi int-to-string (dan kembali) sebagai contoh khusus.

int val_int = 841;
char val_str[] = "841";

Ketika int dikonversi ke string, maka digit paling signifikan lebih mudah untuk diekstraksi daripada digit paling signifikan. Itu semua dapat dilakukan dalam satu loop sederhana dengan kondisi ujung yang sederhana.

val_int = 841;
// Make sure that val_str is large enough.

i = 0;
do // Write at least one digit to care for val_int == 0
{
    // Constants, can be optimized by compiler.
    val_str[i] = '0' + val_int % 10;
    val_int /= 10;
    i++;
}
while (val_int != 0);

val_str[i] = '\0';
// val_str is now in LE "148"
// i is the length of the result without termination, can be used to reverse it

Sekarang coba yang sama dalam urutan BE. Biasanya Anda membutuhkan pembagi lain yang memiliki kekuatan 10 terbesar untuk nomor tertentu (di sini 100). Anda pertama-tama harus menemukan ini, tentu saja. Banyak hal yang harus dilakukan.

Konversi string ke int lebih mudah dilakukan di BE, ketika dilakukan sebagai operasi penulisan balik. Tuliskan menyimpan angka paling signifikan yang terakhir, jadi harus dibaca terlebih dahulu.

val_int = 0;
length = strlen(val_str);

for (i = 0; i < length; i++)
{
    // Again a simple constant that can be optimized.
    val_int = 10*val_int + (val_str[i] - '0');
}

Sekarang lakukan hal yang sama dalam urutan LE. Sekali lagi, Anda memerlukan faktor tambahan yang dimulai dengan 1 dan dikalikan dengan 10 untuk setiap digit.

Jadi saya biasanya lebih suka menggunakan BE untuk penyimpanan, karena nilai ditulis tepat sekali, tetapi membaca setidaknya sekali dan mungkin berkali-kali. Untuk strukturnya yang lebih sederhana, saya biasanya juga pergi rute untuk mengkonversi ke LE dan kemudian membalikkan hasilnya, bahkan jika itu menulis nilai untuk kedua kalinya.

Contoh lain untuk penyimpanan BE adalah pengkodean UTF-8, dan banyak lagi.