Jika Anda ingin mendapatkan sedikit lebih teknis tentang apa kata kunci volatil, pertimbangkan program berikut (Saya menggunakan DevStudio 2005):
#include <iostream>
void main()
{
int j = 0;
for (int i = 0 ; i < 100 ; ++i)
{
j += i;
}
for (volatile int i = 0 ; i < 100 ; ++i)
{
j += i;
}
std::cout << j;
}
Menggunakan pengaturan kompilator (rilis) standar yang dioptimalkan, kompiler membuat assembler berikut (IA32):
void main()
{
00401000 push ecx
int j = 0;
00401001 xor ecx,ecx
for (int i = 0 ; i < 100 ; ++i)
00401003 xor eax,eax
00401005 mov edx,1
0040100A lea ebx,[ebx]
{
j += i;
00401010 add ecx,eax
00401012 add eax,edx
00401014 cmp eax,64h
00401017 jl main+10h (401010h)
}
for (volatile int i = 0 ; i < 100 ; ++i)
00401019 mov dword ptr [esp],0
00401020 mov eax,dword ptr [esp]
00401023 cmp eax,64h
00401026 jge main+3Eh (40103Eh)
00401028 jmp main+30h (401030h)
0040102A lea ebx,[ebx]
{
j += i;
00401030 add ecx,dword ptr [esp]
00401033 add dword ptr [esp],edx
00401036 mov eax,dword ptr [esp]
00401039 cmp eax,64h
0040103C jl main+30h (401030h)
}
std::cout << j;
0040103E push ecx
0040103F mov ecx,dword ptr [__imp_std::cout (40203Ch)]
00401045 call dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (402038h)]
}
0040104B xor eax,eax
0040104D pop ecx
0040104E ret
Melihat output, kompiler telah memutuskan untuk menggunakan register ecx untuk menyimpan nilai dari variabel j. Untuk loop non-volatile (yang pertama) kompiler telah menetapkan i ke register eax. Cukup mudah. Ada beberapa bit yang menarik - lea ebx, [ebx] instruksi secara efektif adalah instruksi nib multibyte sehingga loop melompat ke 16 byte alamat memori yang disejajarkan. Yang lainnya adalah penggunaan edx untuk menambah penghitung loop alih-alih menggunakan instruksi inc eax. Instruksi tambah reg, reg memiliki latensi lebih rendah pada beberapa core IA32 dibandingkan dengan instruksi inc reg, tetapi tidak pernah memiliki latensi lebih tinggi.
Sekarang untuk loop dengan penghitung loop volatile. Penghitung disimpan di [esp] dan kata kunci yang mudah menguap memberi tahu kompiler bahwa nilai harus selalu dibaca dari / ditulis ke memori dan tidak pernah ditugaskan ke register. Kompilator bahkan melangkah lebih jauh dengan tidak melakukan load / increment / store sebagai tiga langkah berbeda (load eax, inc eax, save eax) saat memperbarui nilai penghitung, sebagai gantinya memori diubah secara langsung dalam satu instruksi (sebuah add mem , reg). Cara kode telah dibuat memastikan nilai loop counter selalu up-to-date dalam konteks inti CPU tunggal. Tidak ada operasi pada data yang dapat menyebabkan korupsi atau kehilangan data (karenanya tidak menggunakan load / inc / store karena nilainya dapat berubah selama inc sehingga hilang di store). Karena interupsi hanya dapat dilayani setelah instruksi saat ini selesai,
Setelah Anda memperkenalkan CPU kedua ke sistem, kata kunci yang mudah menguap tidak akan melindungi terhadap data yang diperbarui oleh CPU lain secara bersamaan. Dalam contoh di atas, Anda akan memerlukan data untuk tidak selaras untuk mendapatkan potensi korupsi. Kata kunci yang mudah menguap tidak akan mencegah potensi korupsi jika data tidak dapat ditangani secara atomis, misalnya, jika penghitung putaran bertipe panjang panjang (64 bit) maka akan membutuhkan dua operasi 32 bit untuk memperbarui nilai, di tengah-tengah di mana interupsi dapat terjadi dan mengubah data.
Jadi, kata kunci yang mudah menguap hanya baik untuk data yang disejajarkan yang kurang dari atau sama dengan ukuran register asli sehingga operasi selalu atom.
Kata kunci yang mudah menguap dirancang untuk digunakan dengan operasi IO di mana IO akan terus berubah tetapi memiliki alamat yang konstan, seperti memori yang dipetakan perangkat UART, dan kompiler tidak boleh terus menggunakan kembali nilai pertama yang dibaca dari alamat.
Jika Anda menangani data besar atau memiliki banyak CPU, maka Anda akan memerlukan sistem penguncian tingkat tinggi (OS) untuk menangani akses data dengan benar.