atomicity (again)

[sch...@gmail.com]

Dear all,

I wanted to ask about the atomicity of non-flush data. In the following example, the first assignment is flushed. However, there is a power failure before the second flush.

alignas(64) uint64_t foo = std::numeric_limits<uint64_t>::min();
// flush
foo = std::numeric_limits<uint64_t>::max();
// power failure
// flush

Is there a guarantee, that either min() or max() and nothing else was persisted? Is it possible, that a mix of both was persisted, i.e. individual bytes but not the whole 8 bytes made it to the persistence domain?

The real question is about packed structs of size 8 bytes. I want to use the committed flag to indicate that the data fields are valid. With appropriate casting, I can make updates as 8 byte writes. Would this approach work?

struct __attribute__((__packed__)) metadata {
  bool committed:1;
  unsigned data1:32;
  unsigned data2:31;
};

Thanks,
  Thorsten

[Andy Rudoff]

Hi Thorsten,

Here's my take:  If the assignments happen as 8-byte aligned stores, like I think you're showing in your example code, then after a reboot in your scenario you'll have either the entire 8-bytes from the first assignment, or the entire 8-bytes from the second assignment, but not a mix.

Of course, if you define the packed struct as you said and do assignments to the individual fields, then a cache eviction could happen between any two assignments and you could get partial results persisted.  But the way you described it where the assignment is a single aligned 8-byte store, you should get the atomicity you're looking for.

-andy

[sch...@gmail.com]

Thanks Andy, this helps a lot.

Thorsten