explanations on atomic order

[graceful kestrel]

What atomic orders should i use for what operations, or rather, which orders are commonly used for which operations.

one operation im trying to do is returning an element from an array, it's a copy by value so no modifications.

i've been using seq_cst but i think that's the slowest one so far and probably overkill?

Sorry if i'm a bit vague, very new to atomics

this is the function i have so far.

pub fn getFoo(self: *const FooManager, index: usize) Foo {
    return @atomicLoad(Foo, &self.arr_foo[index], .seq_cst);
}

sadly std.builtin.AtomicOrder has no documentation

[blazing forge]

The ordering only affects other memory operations around the atomic. Should probably avoid atomics if you can help it. Whats arr_foo used for?

[graceful kestrel]

Yeah that went straight over my head, probably because i don't really know atomics.
Anyway arr_foo is an array of blocks similar to a minecraft chunk's blocks.

it's mostly used for reading, but there's a little bit of writing here and there, but initially there's a lot of writing as its being generated.

I wanted to try atomics because im hoping it might be a bit faster than mutex locks.

^ would also mean less potential for dead locks

[blazing forge]

is the value of Foo being used to then read other memory?

e.g. write memory; STORE(&arr_foo[10], v) -> if LOAD(&arr_foo[10]) == v: read_memory

[graceful kestrel]

yes, i check if the old foo contains certain data
if its not, i set the old foo to the new foo.

goes something like this in code

const old_foo = LOAD(&arr_foo[10]);

if (old_foo is something specific)
  return;

arr_foo[10] = new_foo;

[polar magnet]

you can do this atomically via,

@cmpxchgStrong(u32, &arr_foo[10], expected_value, new_foo, ...)

for example.

[raw karma]

Not sure what zig is using for its memory model, but here are the different elements in c++:
https://en.cppreference.com/w/cpp/atomic/memory_order.html