撩动你心 2024-07-14 21:36:10

易失性告诉编译器不要优化与易失性变量有关的任何内容。

使用它至少有三个常见原因，所有这些都涉及变量的值无需可见代码的操作即可更改

的
情况
：有一个信号处理程序可能会更改变量的值。

假设您有一小块硬件映射到 RAM 的某个位置，并且有两个地址：一个命令端口和一个数据端口：

typedef struct
{
  int command;
  int data;
  int isBusy;
} MyHardwareGadget;

现在您想要发送一些命令：

void SendCommand(MyHardwareGadget* gadget, int command, int data)
{
  // wait while the gadget is busy:
  while (gadget->isBusy)
  {
    // do nothing here.
  }
  // set data first:
  gadget->data    = data;
  // writing the command starts the action:
  gadget->command = command;
}

看起来很简单，但它可能会失败，因为编译器可以自由地更改写入数据和命令的顺序。这将导致我们的小工具使用先前的数据值发出命令。另请查看 wait while busy 循环。那个将被优化掉。编译器会尝试变得聪明，只读取一次 isBusy 的值，然后进入无限循环。那不是你想要的。

解决这个问题的方法是将指针gadget声明为易失性。这样编译器就被迫执行您编写的操作。它不能删除内存分配，不能在寄存器中缓存变量，也不能更改分配的顺序

这是正确的版本：

void SendCommand(volatile MyHardwareGadget* gadget, int command, int data)
{
  // wait while the gadget is busy:
  while (gadget->isBusy)
  {
    // do nothing here.
  }
  // set data first:
  gadget->data    = data;
  // writing the command starts the action:
  gadget->command = command;
}

volatile tells the compiler not to optimize anything that has to do with the volatile variable.

There are at least three common reasons to use it, all involving situations where the value of the variable can change without action from the visible code:

When you interface with hardware that changes the value itself
when there's another thread running that also uses the variable
when there's a signal handler that might change the value of the variable.

Let's say you have a little piece of hardware that is mapped into RAM somewhere and that has two addresses: a command port and a data port:

typedef struct
{
  int command;
  int data;
  int isBusy;
} MyHardwareGadget;

Now you want to send some command:

void SendCommand(MyHardwareGadget* gadget, int command, int data)
{
  // wait while the gadget is busy:
  while (gadget->isBusy)
  {
    // do nothing here.
  }
  // set data first:
  gadget->data    = data;
  // writing the command starts the action:
  gadget->command = command;
}

Looks easy, but it can fail because the compiler is free to change the order in which data and commands are written. This would cause our little gadget to issue commands with the previous data-value. Also take a look at the wait while busy loop. That one will be optimized out. The compiler will try to be clever, read the value of isBusy just once and then go into an infinite loop. That's not what you want.

The way to get around this is to declare the pointer gadget as volatile. This way the compiler is forced to do what you wrote. It can't remove the memory assignments, it can't cache variables in registers and it can't change the order of assignments either

This is the correct version:

void SendCommand(volatile MyHardwareGadget* gadget, int command, int data)
{
  // wait while the gadget is busy:
  while (gadget->isBusy)
  {
    // do nothing here.
  }
  // set data first:
  gadget->data    = data;
  // writing the command starts the action:
  gadget->command = command;
}

为什么 C 中需要 volatile？

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（19）

根据 GCC

消除优化效果，

这是栅栏吗？ 关于海湾合作委员会，是的。

Volatile 不做什么

结论

What Volatile Does According to GCC

Eliminating Opimizations Effect

Is It A Fence? On GCC, Yes.

What Volatile Does Not Do

Conclusion

关于作者

相关话题

热门标签

推荐作者

留蓝

18790681156

zach7772

Wini

ayeshaaroy

初雪

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

这是栅栏吗？关于海湾合作委员会，是的。