Memory Model Considerations

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// PROGRAM ORDER (within a single thread)
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Thread A:
x = 1;      // (1)
y = 2;      // (2)
// (1) happens-before (2) due to program order.
// Any read of both x and y by Thread A will see these values.
 
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// SYNCHRONIZATION ORDER (between threads)
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Thread A:
x = 1;              // (1)
release(lock);      // (2) Release lock
 
// Thread B:
acquire(lock);      // (3) Acquire same lock
print(x);           // (4)
 
// (2) happens-before (3) due to lock synchronization.
// Since (1) HB (2) and (2) HB (3) and (3) HB (4):
// By transitivity, (1) happens-before (4).
// Therefore, Thread B is GUARANTEED to see x == 1.
 
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// NO HAPPENS-BEFORE (the dangerous case)
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Thread A:
x = 1;              // (1)
flag = true;        // (2) Regular (non-volatile) write
 
// Thread B:
if (flag) {         // (3) Regular (non-volatile) read
    print(x);       // (4)
}
 
// WITHOUT proper synchronization:
// There is NO happens-before between (2) and (3)!
// Thread B might see flag == true but x == 0 (uninitialized).
// This is EXACTLY the DCL bug.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

/**
 * Volatile provides happens-before edges
 */
public class VolatileSemantics {
    private int nonVolatileData = 0;
    private volatile boolean dataReady = false;  // volatile!
    
    // Thread A: Writer
    public void writer() {
        nonVolatileData = 42;       // (1) Regular write
        dataReady = true;            // (2) Volatile write
        
        // JMM guarantees:
        // (1) happens-before (2) due to program order
        // All writes before a volatile write are visible
        // to any thread that subsequently reads that volatile
    }
    
    // Thread B: Reader
    public void reader() {
        if (dataReady) {             // (3) Volatile read
            int value = nonVolatileData;  // (4) Regular read
            System.out.println(value);
            // GUARANTEED to print 42 (if dataReady was true)
            
            // JMM guarantees:
            // (2) happens-before (3) due to volatile semantics
            // Since (1) HB (2) and (2) HB (3) and (3) HB (4):
            // By transitivity, (1) happens-before (4)
            // Therefore, the read at (4) sees the write at (1)
        }
    }
}
 
/**
 * WITHOUT volatile, this could fail:
 */
public class BrokenVisibility {
    private int nonVolatileData = 0;
    private boolean dataReady = false;  // NOT volatile!
    
    public void writer() {
        nonVolatileData = 42;
        dataReady = true;
    }
    
    public void reader() {
        if (dataReady) {
            int value = nonVolatileData;
            System.out.println(value);
            // MIGHT print 0! No happens-before guarantee.
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <atomic>
#include <thread>
 
/**
 * C++11 Memory Ordering Demonstration
 */
class VisibilityExample {
    int data = 0;                              // Regular variable
    std::atomic<bool> ready{false};            // Atomic variable
    
public:
    void writer() {
        data = 42;                              // (1) Regular write
        
        // Release semantics: All writes before this are visible
        // to any thread that acquires this atomic
        ready.store(true, std::memory_order_release);  // (2)
    }
    
    void reader() {
        // Acquire semantics: All reads after this see writes
        // released by the matching release operation
        if (ready.load(std::memory_order_acquire)) {   // (3)
            int value = data;                          // (4)
            
            // GUARANTEED to see data == 42
            // (1) happens-before (2) due to program order
            // (2) synchronizes-with (3) due to release-acquire
            // (3) happens-before (4) due to program order
            // By transitivity: (1) happens-before (4)
        }
    }
};
 
/**
 * Common mistake: Using relaxed ordering
 */
class BrokenExample {
    int data = 0;
    std::atomic<bool> ready{false};
    
public:
    void writer() {
        data = 42;
        ready.store(true, std::memory_order_relaxed);  // BROKEN!
    }
    
    void reader() {
        if (ready.load(std::memory_order_relaxed)) {   // BROKEN!
            int value = data;
            // May see data == 0! Relaxed provides no ordering.
        }
    }
};
 
/**
 * Sequential consistency: The safest (and slowest) option
 */
class SeqCstExample {
    int data = 0;
    std::atomic<bool> ready{false};  // Default is seq_cst
    
public:
    void writer() {
        data = 42;
        ready.store(true);  // Uses memory_order_seq_cst by default
    }
    
    void reader() {
        if (ready.load()) {  // Uses memory_order_seq_cst by default
            int value = data;
            // GUARANTEED to see data == 42
            // seq_cst is equivalent to release-acquire plus global ordering
        }
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/**
 * How volatile in Java translates to barriers
 */
 
// Java:
volatile int flag;
 
// Writing to volatile (release semantics):
// Before: x = 1; y = 2;
// Barrier: [StoreStore] + [LoadStore]
// After: flag = value;
// Result: x and y writes complete before flag write is visible
 
// Reading from volatile (acquire semantics):
// Before: value = flag;
// Barrier: [LoadLoad] + [LoadStore]
// After: a = x; b = y;
// Result: flag read completes before x and y reads
 
/**
 * Why DCL needs these barriers
 */
 
// Thread A (creating singleton):
//   1. Allocate memory
//   2. Initialize fields: obj.field1 = ...; obj.field2 = ...;
//   3. [Release Barrier] — ensures field writes complete
//   4. Write reference: instance = obj;
 
// Thread B (reading singleton):
//   1. Read reference: temp = instance;
//   2. [Acquire Barrier] — ensures subsequent reads see init
//   3. If temp != null, use fields: temp.field1, temp.field2
 
// The release-acquire pair creates the happens-before edge
// that guarantees Thread B sees the initialized fields.
 
/**
 * x86 architecture (strong memory model):
 * - StoreStore, LoadLoad, LoadStore barriers are free (no-ops)
 * - Only StoreLoad requires an actual fence instruction (MFENCE)
 * - This is why DCL bugs often don't manifest on x86
 */
 
/**
 * ARM architecture (weak memory model):
 * - All barrier types may require actual instructions
 * - DMB (Data Memory Barrier) instructions are needed
 * - DCL bugs are much more likely to manifest on ARM
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
 * CORRECT Double-Checked Locking in Java 5+
 * The key fix is: volatile keyword on instance
 */
public class Singleton {
    // volatile ensures happens-before edge from construction to read
    private static volatile Singleton instance = null;  // ← THE FIX
    
    private Singleton() {
        // Constructor initializes all fields
    }
    
    public static Singleton getInstance() {
        // First check: Uses volatile read semantics
        // If non-null, has happens-before edge from the write
        if (instance == null) {
            synchronized (Singleton.class) {
                // Second check: Protected by lock
                if (instance == null) {
                    // Construction completes...
                    // Volatile write ensures all constructor
                    // writes happen-before this assignment
                    instance = new Singleton();  // volatile write
                }
            }
        }
        // Volatile read: sees fully constructed object or null
        return instance;
    }
}
 
/**
 * Trace through with happens-before:
 * 
 * Thread A creates singleton:
 * A1: field1 = value1;           // Constructor writes
 * A2: field2 = value2;           // Constructor writes
 * A3: instance = this;           // Volatile write
 *     [All of A1, A2 happen-before A3 due to program order]
 *     [A3 publishes with release semantics]
 * 
 * Thread B reads singleton:
 * B1: temp = instance;           // Volatile read
 *     [A3 happens-before B1 due to volatile semantics]
 *     [Therefore A1, A2 happen-before B1 by transitivity]
 * B2: temp.field1;               // Sees value1
 * B3: temp.field2;               // Sees value2
 */