C言語/volatile

はじめに

C言語におけるvolatileキーワードは、コンパイラの最適化動作を制御するための重要な型修飾子です。volatileは特に、ハードウェア操作、マルチスレッドプログラミング、割り込み処理などの低レベルプログラミングにおいて重要な役割を果たします。C23（ISO/IEC 9899:2024）では、volatileの挙動と使用法がさらに明確化されています。

volatileの基本概念

volatileキーワードは、変数の値が予期せず変更される可能性があることをコンパイラに伝えます。これにより、コンパイラはその変数に対する最適化（不要と思われるメモリアクセスの削除など）を制限します。

volatile int sensor_value;  // センサーからの読み取り値など、外部要因で変化する可能性がある変数

void readSensor(void) {
    int value1 = sensor_value;  // この読み取りは最適化されない
    // 何らかの処理
    int value2 = sensor_value;  // コードに変更がなくても、この2回目の読み取りも維持される
}

volatileがなければ、コンパイラは2回目の読み取りを最適化により削除する可能性があります。

volatileが必要なケース

volatile修飾子が必要とされる主な状況は以下の通りです。

// 1. メモリマップドI/O（ハードウェアレジスタ）
volatile uint32_t *gpio_register = (volatile uint32_t *)0x40020000;

// 2. 割り込みハンドラから変更される変数
volatile bool interrupt_occurred = false;

// 3. マルチスレッド環境で共有される変数（ただしC11以降は原子操作が推奨）
volatile int shared_counter = 0;

ポインタとvolatile

constと同様に、volatile修飾子もポインタと組み合わせて使用できます。その位置によって意味が変わります。

volatile int *p1;        // ポインタが指す値が予期せず変化する可能性がある
int volatile *p2;        // 上と同じ意味
int * volatile p3 = &x;  // ポインタ自体が予期せず変化する可能性がある
volatile int * volatile p4 = &y;  // ポインタ自体も指す値も予期せず変化する可能性がある

実際の使用例：

void volatilePointerDemo(void) {
    int x = 10, y = 20;
    
    // 値が外部要因で変化する可能性
    volatile int *p1 = &x;
    *p1 = 30;            // この書き込みは最適化されない
    int temp = *p1;      // この読み取りは最適化されない
    p1 = &y;             // ポインタの変更は通常どおり
    
    // ポインタ自体が外部要因で変化する可能性
    int * volatile p2 = &x;
    *p2 = 30;            // 通常の書き込み
    p2 = &y;             // このポインタ変更は最適化されない
    
    // 両方が外部要因で変化する可能性
    volatile int * volatile p3 = &x;
    *p3 = 30;            // この書き込みは最適化されない
    p3 = &y;             // このポインタ変更も最適化されない
}

関数パラメータとしてのvolatile

関数パラメータにvolatileを指定することで、その関数内での変数アクセスが最適化されないことを保証します。

void updateHardwareRegister(volatile uint32_t *reg, uint32_t value) {
    *reg = value;  // このメモリ書き込みは最適化されない
}

void processSensorData(volatile const int *sensor_data, int length) {
    int sum = 0;
    for (int i = 0; i < length; i++) {
        sum += sensor_data[i];  // 各読み取りは独立して実行される
    }
    // 処理結果を使用...
}

構造体とvolatile

構造体全体または特定のメンバーにvolatileを適用できます。

// ハードウェアレジスタを表す構造体
typedef struct {
    volatile uint32_t control;
    volatile uint32_t status;
    volatile uint32_t data;
} HardwareRegister;

// メモリマップドI/O
volatile HardwareRegister *uart = (volatile HardwareRegister *)0x40013800;

void sendByte(char byte) {
    // UARTの状態フラグが準備完了になるまで待機
    while (!(uart->status & 0x80)) {
        // 各ループでの読み取りは最適化されない
    }
    uart->data = byte;  // この書き込みは最適化されない
}

volatileとconstの組み合わせ

volatileとconstを組み合わせると、「変更不可だが値は予期せず変化する可能性がある」という一見矛盾した状態を表現できます。これは、読み取り専用のハードウェアレジスタなどで使用されます。

// 読み取り専用のセンサー値（プログラムからは変更不可だが外部要因で変化する）
volatile const int *sensor_reading = (volatile const int *)0x40020010;

void monitorSensor(void) {
    int current = *sensor_reading;  // この読み取りは最適化されない
    // sensor_reading = 100;  // エラー: const なので変更不可
    
    // 処理...
    
    int updated = *sensor_reading;  // この二度目の読み取りも維持される
}

C23におけるvolatileの拡張と明確化

C23（ISO/IEC 9899:2024）では、volatileに関する仕様がさらに明確化されています。

メモリモデルとの関係

C23では、volatileアクセスのメモリオーダリングに関する規定が強化されています。

volatile int shared_flag = 0;

// スレッド1
void thread1(void) {
    shared_data = computed_value;  // 共有データの更新
    shared_flag = 1;               // フラグの設定（この順序は保証される）
}

// スレッド2
void thread2(void) {
    while (shared_flag == 0) {     // フラグのチェック
        // 待機
    }
    use_shared_data();             // 共有データの使用（この順序は保証される）
}

C23では、volatileアクセスの順序が保持されることがより明確に規定されています。

アトミック操作との相互作用

C23では、volatileと_Atomic修飾子の相互作用が明確化されています。

// C23では、これらの異なる型修飾子の組み合わせの意味がより明確に定義されている
_Atomic volatile int atomic_volatile_counter = 0;

メモリアクセスとvolatileの相互作用

C23では、様々な型修飾子の組み合わせにおけるメモリアクセスの挙動が表で整理されています。

修飾子の組み合わせ	最適化制限	メモリアクセス動作	スレッド間の可視性
`int *`	なし	通常	保証なし
`volatile int *`	あり	毎回実際にアクセス	順序のみ保証
`_Atomic int *`	なし	アトミック	同期可能
`volatile _Atomic int *`	あり	アトミック＋毎回アクセス	順序と同期の両方
`const volatile int *`	あり	読み取り専用、毎回アクセス	順序のみ保証

volatileの一般的な誤用

volatileは強力なキーワードですが、誤用されることも多いです。以下は一般的な誤用と適切な代替手段です。

// 誤用1: スレッド同期のために使用（C11以降では非推奨）
volatile int shared_data = 0;  // マルチスレッド環境での共有変数

// 適切な代替手段: アトミック操作を使用
#include <stdatomic.h>
atomic_int shared_data_atomic = 0;

// 誤用2: すべての最適化を防ぐために使用
volatile int calculation_result;  // 最適化を防ぐためだけに volatile を使用

// 適切な代替手段: 必要な場合のみ volatile を使用し、コンパイラの最適化を信頼する

実際のハードウェア制御例

volatileの実用的な使用例として、マイクロコントローラのハードウェア制御を示します。

// ARM Cortexマイクロコントローラの一般的なペリフェラルレジスタの例
typedef struct {
    volatile uint32_t CR;     // コントロールレジスタ
    volatile uint32_t SR;     // ステータスレジスタ
    volatile uint32_t DR;     // データレジスタ
    volatile uint32_t BRR;    // ボーレートレジスタ
} UART_TypeDef;

// メモリマップドI/O
#define UART1_BASE 0x40013800
#define UART1 ((UART_TypeDef *)UART1_BASE)
void uartInit(void) {
    // UARTの初期化
    UART1->BRR = 0x0683;  // 9600ボーレート
    UART1->CR = 0x200C;   // UARTを有効化
}

void uartSendChar(char c) {
    // 送信バッファが空になるまで待機
    while (!(UART1->SR & 0x0080)) {}
    
    // データ送信
    UART1->DR = c;
}

この例では、volatileがなければコンパイラはループ内のレジスタ読み取りを最適化により削除する可能性があります。

C23でのvolatile使用のベストプラクティス

C23を踏まえたvolatile使用のベストプラクティスは以下の通りです。

// 1. ハードウェアレジスタには volatile を使用
volatile uint32_t *gpio = (volatile uint32_t *)0x40020000;

// 2. マルチスレッドプログラミングでは _Atomic を優先
#include <stdatomic.h>
atomic_int shared_counter = 0;  // volatile ではなく _Atomic を使用

// 3. 特殊なケースでは両方を組み合わせる
volatile _Atomic int special_counter = 0;

// 4. メモリバリアが必要な場合は明示的に指定
#include <stdatomic.h>
atomic_thread_fence(memory_order_acquire);  // メモリバリア

まとめ

C23におけるvolatileキーワードは、主にハードウェアインターフェース、割り込み処理、特殊なメモリアクセスパターンで使用される重要な型修飾子です。その主な役割は、コンパイラの最適化を制限し、すべてのメモリアクセスが実際に実行されることを保証することです。

volatileは文脈によって異なる意味を持ち、ポインタの値、ポインタ自体、構造体メンバーなど、様々な要素に適用できます。また、constや_Atomicなどの他の型修飾子と組み合わせることで、より複雑なメモリアクセスパターンを表現できます。

C23では、volatileのメモリモデルとの相互作用、アトミック操作との関係、および最適化に対する影響がより明確に定義されています。これにより、低レベルプログラミングでのvolatileの適切な使用がさらに容易になっています。

しかし、volatileは特定の目的のために設計されており、スレッド同期やすべての最適化を防ぐための汎用ツールとして誤用すべきではありません。適切な状況で適切に使用することで、volatileはハードウェア制御や特殊なメモリアクセスパターンを必要とするプログラムにおいて、強力かつ効果的なツールとなります。