cmpxchg function is missing the loaded value

[andrewrk]

@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> bool

cmpxchg is supposed to be a read-modify-write atomic operation. It should provide a way to return the read value.

It should return ?T instead:

@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> ?T

[andrewrk]

I need to remind myself of the use of cmpxchg, but it looks like the case where you actually need to use T is the failure case. So maybe just return an anonymous struct:

@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> struct { success: bool, old_value: T}

[andrewrk]

Let's make sure these compile errors are in place too:

The type of ‘cmp’ must be an integer or pointer type whose bit width is a power of two greater than or equal to eight and less than or equal to a target-specific size limit.

[kyle-github]

Alternatively, you could return the value that was there (this is what similar calls do in Windows and Linux).

@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> %T

I suggest modifying this to have the return type be %T. It is either an error (for instance bad alignment) or you get a valid T value. If the T value is the old value (cmp), then the swap succeeded. If the T value is something else, then the swap failed.

const old = %return @cmpxchg(myTPtr, oldVal, newVal, ?, ?);

if(old == oldVal) {
   ... successful swap ...
else {
   ... failure ...
}

(Have I mentioned, lately, how much I like the error idea in Zig?)

[kyle-github]

Oops, forgot to comment about the size. All processors that support some form of CAS ("compare and swap" is the generic way this is referenced in the literature) usually only support a very small number of sizes so this is inherently a platform specific operation. Virtually all CPUs that support it at all support at least a single machine word. Some support DCAS (double compare and swap) and a few support QCAS (quad compare and swap). I am not aware of any that support some form of CAS that is not single machine word at least.

Where things get a little frustrating is that "machine word" is not a very solid thing. Is that the size of an address? Of an integer register?

I do not have any good answers here, but I usually assume that you can swap an address IFF the size of an address is something relatively sane. I.e. Intel's weird addressing modes with explicit segments do not work.