C ++ volátil

“Os desenvolvedores de aplicativos de espaço do usuário devem sempre fazer referência aos manuais do compilador relevante para saber como o qualificador pode ser tratado em vários contextos, porque o comportamento volátil da palavra-chave deve ser visto normalmente como dependente de hardware. Quando um objeto é marcado como volátil, o compilador é frequentemente informado de que nunca deve ser otimizado para operações de carga e sempre deve ser recuperado da memória primária, em vez de registros ou caches. No entanto, quando o compilador tenta colocar o local da memória no registro, ele fica automaticamente em cache, embora existam numerosos níveis de caches que são praticamente indisponíveis para o software e mantidos apenas no hardware. Como resultado, a RAM pode ser acessada muitas vezes mais rápida a partir de linhas de cache perto da CPU do que do local de memória idêntica.

Os problemas podem ocorrer se não usarmos um qualificador volátil que inclua, quando a otimização é ativada, o código pode não funcionar conforme o esperado. Quando as interrupções são utilizadas e ativadas, o código não pode funcionar como planejado. Os dados são retidos apenas em armazenamento volátil enquanto a energia está ligada. Quando o suprimento é removido, a perda de dados acontece.

No entanto, o armazenamento não volátil mantém os dados, mesmo que a energia seja apagada. As informações do processo são brevemente armazenadas no armazenamento volátil, pois são consideravelmente mais rápidas que o armazenamento não volátil. Ao contrário do armazenamento não volátil, o armazenamento volátil é mais adequado para proteger dados sensíveis. Isso ocorre porque os dados são inacessíveis quando a fonte de alimentação é desligada. O armazenamento volátil custa muito porque os sistemas de computador podem acomodar apenas alguns MB a alguns GB.”

Propriedades do qualificador volátil em C++

Os meios de qualificador volátil C ++ serão demonstrados aqui. Quando declaramos uma variável, o qualificador “volátil” é aplicado. Serve como um lembrete ao compilador de que o valor é responsável por variar a qualquer momento. O volátil possui algumas das características listadas abaixo.

• A atribuição de memória não pode ser alterada com a palavra -chave volátil.

• As variáveis ​​do registro não podem ser armazenadas em cache.

• Em termos de atribuição, o valor não pode ser alterado.

Uso do qualificador volátil em C++

1. Apesar do seu código não modificar o valor da variável, no entanto, pode fazê -lo. Como resultado, cada vez que o compilador verifica o estado da variável, não pode assumir que é o mesmo que o valor mais recente lido dela ou o valor mais recente armazenado; Pelo contrário, deve adquirir o valor da variável mais uma vez.

2. O compilador não é obrigado a eliminar o ato de armazenar um valor, pois é um "efeito colateral" que pode ser visto de fora e ocorre quando um valor é salvo em uma variável volátil. Por exemplo, se dois valores forem colocados em uma linha, o compilador deve colocar o valor duas vezes.

Sintaxe do qualificador volátil em C++

# Volátil data_type variable_name

A palavra -chave volátil deve ser usada na declaração, e o tipo de dados refere -se a qualquer tipo de dados, incluindo duplo, flutuação ou número inteiro. Finalmente, escolhemos um nome para a variável. Podemos definir uma variável volátil usando qualquer um dos métodos, pois ambas as declarações são válidas.

Exemplo: o qualificador volátil é usado para identificar objetos que podem ser modificados por outros threads ou ações externas em c++

Se o objeto for alterado por um sinal externo ou um procedimento que age como uma interrupção, o valor alterado precisará ser recuperado da RAM porque o estado em cache não é mais apropriado nesse meio tempo. Como resultado, o compilador lida com acesso a objetos voláteis adequadamente.

#incluir
#incluir
#incluir
usando std :: cout;
usando std :: endl;
usando std :: Cerr;
usando std :: CIN;
Segundos voláteis int = 0;
void deLearfiveSeconds ()
enquanto (segundos < 3)
USleep (200000);
Cerr<< "waiting… " <

Void incrementsEconds ()
para (int i = 0; i< 5; ++i)
sono (1);
Cerr<< "incremented " <segundos = segundos + 1;


int main ()
struct timeval start ;
struct timeval end ;
std :: thread Thread1;
thread1 = std :: thread (incrementos e segundos);
TouchfiveSeconds ();
Thread1.juntar();
return exit_success;

Para ilustrar o cenário potencial, usamos a palavra -chave volátil que tem a variável declarada como segundos do tipo de dados "int" e atribuímos um valor de 0 a ele. Em seguida, construímos duas funções: uma como "atrasoFiveSeconds" que altera a variável inteira volátil global e outra como "incrementos -segundos" que executa a mesma avaliação dentro de um loop while. Deve -se notar que este exemplo permite que o loop do tempo tenha loop sobre os segundos, quando os segundos devem ser menores que 3.

Quando a condição se encontrar, então o bloqueio será executado. Dentro do bloqueio do tempo, invocamos o método de unsleep que imprime a declaração "esperando". A função "incrementosceonds" tem o loop for. Após a iteração, o método do sono é invocado, que imprime a declaração "incremento" e incrementa a variável "segundos". A execução inicial da função "incrementos -segundos" é feita por um encadeamento separado criado pela função principal. O método "AtardFiveSeconds" é então chamado pelo fio principal, entrando em um loop que não terminará se a variável segundos não se mover acima do valor de 5.

Assim que o tópico principal perceber o valor da variável dos segundos, ele retornará do método porque outro tópico já começou a aumentá -lo simultaneamente.

Para executar o código do thread em C ++, devemos usar o comando “g ++ -thread -o filename filename.CC ”. Se você não implantar o "-thread" no comando, há uma chance de uma exceção ser jogada pelo compilador. Como resultado, efetivamente fizemos uma função de espera condicional que aguarde até que o objeto volátil seja alterado por uma força externa. É importante ter em mente que o bloco de código de atualização pode vir de uma seção de tradução diferente ou ação externa do sinal, mesmo que esse código ainda funcione da mesma forma se o qualificador volátil for removido e uma variável global convencional for utilizada.

Conclusão

Aqui, analisamos uma visão geral do volátil em C ++ junto com a sintaxe, uso e exemplos apropriados para um melhor entendimento. Como o compilador não pode prever o valor, o volátil é crucial na programação C. O principal benefício de utilizar volátil é que seu valor pode variar sempre que um usuário solicitar que seja modificado ou quando algum outro tópico utilizando a mesma variável está ativo.