Welche Funktion hat das Schlüsselwort volatile in der C-Sprache?

Die Rolle des Schlüsselworts volatile in der C-Sprache: erinnert den Compiler daran, dass sich die später definierte Variable jederzeit ändern kann. Weisen Sie den Compiler daher jedes Mal an, wenn das kompilierte Programm diese Variable speichern oder lesen muss, nichts mit der Variablen zu tun Durch die Optimierung werden Daten direkt von der variablen Speicheradresse gelesen, wodurch ein stabiler Zugriff auf spezielle Adressen gewährleistet wird, um Fehler zu vermeiden. ? CPU-Verarbeitungsgeschwindigkeit: Um die Gesamtleistung der Maschine zu verbessern, wird auf der Hardware ein Hardware-Cache eingeführt, um den Zugriff auf den Speicher zu beschleunigen. Darüber hinaus folgt die Ausführung von Anweisungen in modernen CPUs nicht unbedingt einer strengen Reihenfolge. Anweisungen ohne Korrelation können außerhalb der Reihenfolge ausgeführt werden, um die Befehlspipeline der CPU vollständig zu nutzen und die Ausführungsgeschwindigkeit zu verbessern. Bei den oben genannten handelt es sich um Optimierungen auf Hardwareebene. Schauen wir uns die Optimierung auf Softwareebene an: Eine wird vom Programmierer beim Schreiben von Code optimiert, die andere wird vom Compiler optimiert.

Zu den häufig verwendeten Methoden zur Compileroptimierung gehören: Zwischenspeichern von Speichervariablen in Registern; Anpassen der Befehlsreihenfolge, um die CPU-Befehlspipeline voll auszunutzen. Eine gängige Methode ist die Neuordnung von Lese- und Schreibanweisungen. Bei der Optimierung konventionellen Speichers sind diese Optimierungen transparent und sehr effizient. Die Lösung für Probleme, die durch Compiler-Optimierung oder Hardware-Neuordnung verursacht werden, besteht darin, eine Speicherbarriere zwischen Vorgängen zu platzieren, die aus Sicht der Hardware (oder anderer Prozessoren) in einer bestimmten Reihenfolge ausgeführt werden müssen. Linux bietet eine Makrolösung.

void Barrier(void)

Diese Funktion benachrichtigt den Compiler, eine Speicherbarriere einzufügen, ist jedoch für Hardware ungültig. Der kompilierte Code speichert alle geänderten Werte im aktuellen CPU-Register im Speicher und ruft sie dann aus dem Speicher ab Diese Daten werden ausgelesen.

2. Volatile ist immer mit der Optimierung verbunden. Der Compiler verfügt über eine Technologie namens Datenflussanalyse, die analysiert, wo die Variablen im Programm verwendet werden und wo sie fehlschlagen Für eine ständige Zusammenführung und ständige Weitergabe kann auf Optimierung verzichtet werden. Manchmal sind diese Optimierungen jedoch vom Programm nicht erforderlich. In diesem Fall können Sie das Schlüsselwort volatile verwenden, um diese Optimierungen zu verhindern.

2. Ausführliche Erklärung von volatile:

1. Prinzip und Funktion:

Die ursprüngliche Bedeutung von volatile ist „flüchtig“, da der Zugriff auf Register viel schneller ist als der Zugriff auf Speichereinheiten, also Compiler Im Allgemeinen werden Optimierungen vorgenommen, um den Zugriff auf den Speicher zu reduzieren, es können jedoch fehlerhafte Daten gelesen werden.

Wenn es erforderlich ist, volatile zu verwenden, um einen Variablenwert zu deklarieren, liest das System die Daten immer erneut aus dem Speicher, in dem sie sich befinden, auch wenn die vorherige Anweisung die Daten gerade von dort gelesen hat.

Um genau zu sein: Wenn der Compiler auf eine mit diesem Schlüsselwort deklarierte Variable stößt, optimiert er den Code, der auf die Variable zugreift, nicht mehr (Daten werden direkt von der Variablenspeicheradresse gelesen) und ermöglicht so den Zugriff auf spezielle Adressen Zugriff; wenn volatile nicht verwendet wird, optimiert der Compiler die deklarierte Anweisung. (Um es einfach auszudrücken: Das Schlüsselwort volatile beeinflusst das Ergebnis des Compilers. Eine mit volatile deklarierte Variable bedeutet, dass sich die Variable jederzeit ändern kann. Führen Sie keine Kompilierungsoptimierung für Vorgänge im Zusammenhang mit der Variablen durch, um Fehler zu vermeiden.)

2. Schauen wir uns zwei Beispiele an:

1>

Sagen Sie dem Compiler

, dass er keine Optimierung durchführen kann

Wenn Sie beispielsweise zwei Anweisungen an eine bestimmte Adresse senden möchten:

int *ip =...; //设备地址 
*ip = 1; //第一个指令 
*ip = 2; //第二个指令

Der obige Programm-Compiler kann optimiert werden:

int *ip = ...; 
*ip = 2;

Das Ergebnis ist, dass die erste Anweisung verloren geht. Wenn Sie volatile verwenden, lässt der Compiler keine Optimierung zu und stellt so die ursprüngliche Absicht des Programms sicher:

volatile int *ip = ...; 
*ip = 1; 
*ip = 2;

Selbst wenn Sie möchten, dass der Compiler optimiert, werden die beiden Gehaltsabrechnungen nicht in eine umgewandelt. Es können nur andere Optimierungen durchgeführt werden.

2>

Mit volatile
definierte Variablen werden außerhalb des Programms geändert und müssen jedes Mal aus dem Speicher gelesen werden, und die im Cache oder Register abgelegte Sicherung kann nicht wiederverwendet werden.

Zum Beispiel:

volatile char a;
a=0;
while(!a){
//do some things;
}
doother();

如果没有 volatiledoother()不会被执行

3.下面是使用volatile变量的几个场景：

1>中断服务程序中修改的供其它程序检测的变量需要加volatile；

例如:

static int i=0;
int main(void)
{
     ...
     while (1){
if (i) dosomething();
}
｝
/* Interrupt service routine. */
void ISR_2(void)
{
      i=1;
}

程序的本意是希望ISR_2中断产生时，在main函数中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被调用。如果将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。

2>多任务环境下各任务间共享的标志应该加volatile

3>存储器映射的硬件寄存器通常也要加voliate，因为每次对它的读写都可能有不同意义。

例如：

假设要对一个设备进行初始化，此设备的某一个寄存器为0xff800000。

int  *output = (unsigned  int *)0xff800000;//定义一个IO端口；
int   init(void)
{
      int i;
      for(i=0;i< 10;i++){
         *output = i;
      }
}

经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为9，所以编译器最后给你编译编译的代码结果相当于：

int  init(void)
{
      *output = 9;
}

如果你对此外部设备进行初始化的过程是必须是像上面代码一样顺序的对其赋值，显然优化过程并不能达到目的。反之如果你不是对此端口反复写操作，而是反复读操作，其结果是一样的，编译器在优化后，也许你的代码对此地址的读操作只做了一次。然而从代码角度看是没有任何问题的。这时候就该使用volatile通知编译器这个变量是一个不稳定的，在遇到此变量时候不要优化。

例如：

volatile  int *output=(volatile unsigned int *)0xff800000;//定义一个I/O端口

另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实现，2中禁止任务调度，3中则只能依靠硬件的良好设计。

4.几个问题

 1)一个参数既可以是const还可以是volatile吗？

可以的，例如只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2) 一个指针可以是volatile 吗？

可以，当一个中服务子程序修该一个指向一个buffer的指针时。

5.volatile的本质：

1> 编译器的优化

在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致。

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。

当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致。

2>volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人。

6.下面的函数有什么错误：

int square(volatile int *ptr)
{
return *ptr * *ptr;
}

该程序的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

注意：频繁地使用volatile很可能会增加代码尺寸和降低性能,因此要合理的使用volatile。

更多编程相关知识，请访问：编程教学！！

Das obige ist der detaillierte Inhalt vonWelche Funktion hat das Schlüsselwort volatile in der C-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!