Se você quiser ser um pouco mais técnico sobre o que a palavra-chave volátil faz, considere o seguinte programa (estou usando o 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;
}
Usando as configurações padrão do compilador otimizado (versão), o compilador cria o seguinte assembler (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
Observando a saída, o compilador decidiu usar o registro ecx para armazenar o valor da variável j. Para o loop não volátil (o primeiro), o compilador atribuiu i ao registro eax. Bastante direto. No entanto, existem alguns bits interessantes - a instrução lea ebx, [ebx] é efetivamente uma instrução nib multibyte, de modo que o loop salta para um endereço de memória alinhado de 16 bytes. O outro é o uso de edx para incrementar o contador de loop em vez de usar uma instrução inc eax. A instrução add reg, reg possui menor latência em alguns núcleos IA32 em comparação com a instrução inc reg, mas nunca possui latência mais alta.
Agora, para o loop com o contador de loop volátil. O contador é armazenado em [esp] e a palavra-chave volátil informa ao compilador que o valor deve sempre ser lido / gravado na memória e nunca atribuído a um registro. O compilador chega ao ponto de não fazer um carregamento / incremento / armazenamento em três etapas distintas (carregar eax, inc eax, salvar eax) ao atualizar o valor do contador, em vez disso, a memória é modificada diretamente em uma única instrução (um add mem , reg). A maneira como o código foi criado garante que o valor do contador de loop esteja sempre atualizado no contexto de um único núcleo da CPU. Nenhuma operação nos dados pode resultar em corrupção ou perda de dados (portanto, não é possível usar a carga / inc / armazenamento, pois o valor pode mudar durante o inc, perdendo assim no armazenamento). Como as interrupções só podem ser reparadas após a conclusão da instrução atual,
Depois de introduzir uma segunda CPU no sistema, a palavra-chave volátil não se protegerá contra a atualização dos dados por outra CPU ao mesmo tempo. No exemplo acima, você precisaria que os dados estivessem desalinhados para obter uma possível corrupção. A palavra-chave volátil não impedirá a corrupção em potencial se os dados não puderem ser manipulados atomicamente, por exemplo, se o contador de loop for do tipo longo (64 bits), serão necessárias duas operações de 32 bits para atualizar o valor, no meio de qual uma interrupção pode ocorrer e alterar os dados.
Portanto, a palavra-chave volátil é boa apenas para dados alinhados que são menores ou iguais ao tamanho dos registros nativos, de modo que as operações sejam sempre atômicas.
A palavra-chave volátil foi concebida para ser usada com operações de E / S nas quais o IO mudava constantemente, mas tinha um endereço constante, como um dispositivo UART mapeado na memória, e o compilador não deve continuar reutilizando o primeiro valor lido do endereço.
Se você estiver lidando com dados grandes ou tiver várias CPUs, precisará de um sistema de bloqueio de nível superior (SO) para lidar com o acesso a dados corretamente.