Why struct of 2 long variables is not lock free?

Summary

The issue at hand is the discrepancy between the expected lock-free behavior of a struct containing two long variables and the actual behavior observed when using std::atomic with the -latomic flag on an x86-64 GCC 15-2 compiler. The key takeaway is that the struct is not lock-free as expected.

Root Cause

The root cause of this issue lies in the way alignment and padding work in C++. Although the struct seems simple, the compiler may add padding bytes to ensure proper alignment of the variables. The main causes are:

• Alignment requirements: The long data type has specific alignment requirements that may cause the compiler to add padding bytes.
• Size of the struct: The size of the struct must be a multiple of the alignment requirement, which can lead to additional padding bytes.
• Atomic operation constraints: std::atomic operations have specific constraints, including the requirement that the type must be trivially copyable and have a size that is a power of 2, which may not be met by the struct in question.

Why This Happens in Real Systems

This issue occurs in real systems because of the complexity of compiler optimizations and the specific requirements of atomic operations. The compiler may optimize the code in ways that affect the alignment and padding of the struct, leading to unexpected behavior. Additionally, the hardware may have specific requirements for atomic operations, which can further complicate the issue.

Real-World Impact

The real-world impact of this issue is significant, as it can lead to:

• Performance issues: The use of locks instead of lock-free operations can significantly impact performance in multithreaded applications.
• Correctness issues: The incorrect assumption that a struct is lock-free can lead to correctness issues and bugs that are difficult to identify and fix.

Example or Code

struct A { long x; long y; A() = default; };
int main() {
    std::cout << "sizeof(A): " << sizeof(A) << std::endl;
    std::atomic a{};
    std::cout << "is A lock_free: " << a.is_lock_free() << std::endl;
    return 0;
}