One scalar value, and the only part of a DeviceParameter that two threads touch at once.
The value is a plain uint64_t reached through std::atomic_ref, so the lock-free guarantee sits on the access rather than on the storage. That is what keeps DeviceParameter copyable and movable — a std::atomic member would be neither, and the struct must be both, because Device::parameter and parametersOrdered hand out copies.
The copy has to be atomic too, and this type is why. A bare member would be read by the compiler-generated copy constructor as an ordinary load, racing the RT thread's store — undefined behaviour that ThreadSanitizer reports on every Device::parameter call, and that the concurrency tests found the first time they ran. Wrapping the value fixes it without writing DeviceParameter's five special members by hand: a field added to that struct later cannot break this, because the compiler still generates its copy and this type still does the atomic access. Hand-written special members are the hazard the wrapper avoids — a field added and forgotten in one of them loses data silently.
Relaxed ordering throughout, and that is the whole requirement: the value is self-contained with no companion state to order against, and a reader is by definition unsynchronised with the writer that published it. No torn or invented value, and the last store becomes visible — which is exactly what a cyclic task needs.
mutable because a load is a const operation while std::atomic_ref needs a non-const lvalue, and because an output cell is written through a const DeviceParameter*.
1.9.8