I understand atomic operations under linux

What is an atomic operation:

Atomic operation is either not executed, once executed, it will be executed and completed. It is an uninterrupted one, or a series of actions, that is, it will not be interrupted by other events before completing the task, just like atoms cannot be interrupted.Divide into particles.In uniprocessing, an instruction that can be completed with a single instruction can be considered an atomic operation.Atomic operations in software depend on the support of hardware atomic operations.Of course, atomic operations can also be used as reference counting.

In fact, atomic operations and locks achieve the same function in essence, both to protect shared objects, which are atomic and sequential.Atomicity ensures that instructions are not interrupted during execution, either all or not at all.Sequentiality ensures that even if two or more instructions appear in separate threads of execution, or even on separate processors, the order in which they should be executed is maintained.

Atomic operations will be interrupted, but will not affect the result:

In the process of performing an atomic operation, it may be interrupted by other execution flows, such as interruption, process switching, but this does not affect the result.If process 1 is interrupted after ldrex, process 2 will clear Exclusive after executing strex.After process 2 is executed, go to process 1. When process 1 executes strex, because Exclusive is cleared, the content of strex will not be executed, directly set temp to 1, compare temp is not 0, jump to 1 to continueExecute, so that the results of the operation are guaranteed.

1:ldrex [result], [v->counter] //Give the value of counter to result and set the global flag "Exclusive"add [result], [result], [i] //result+1 and pass the value to resultstrex [temp], [result], [v->counter] //Give the value of result to counter, if successful temp=0, clear "Exclusive"teq [temp], #0 //compare temp with 0bne 1b //temp is not equal to 0, then jump to the first 1 to continue the operation

In linux, the kernel provides two sets of atomic operation interfaces: one is to operate on integers; the other is to operate on individual bits.

Atomic operations are defined for integer types:

• atomic_t v = ATOMIC_INIT(0); //Define atomic variable v and initialize it to 0
• atomic_read(atomic_t *v); //Returns the value of the atomic variable
• atomic_set(atomic_t *v); //Set the value of the atomic variable
• atomic_add(int i, atomic_t *v) //Add i to an atomic variable
• atomic_add_return(int i, atomic_t *v) //Add i to an atomic variable and return the latest value of variable v
• atomic_sub(int i, atomic_t *v) //Subtract i from an atomic variable
• atomic_sub_return(int i, atomic_t *v) //Subtract i from an atomic variable and return the latest value of variable v
• void atomic_inc(atomic_t *v); //Increase the atomic variable by 1
• void atomic_dec(atomic_t *v); //Atomic variable is reduced by 1
• int atomic_dec_and_test(atomic_t *v); //Test whether it is 0 after the decrement operation, if it is 0, return true, otherwise return false.

Atomic operations are defined for bit types:

• void set_bit(nr, void *addr); //Set the bit, set the nrth bit of the addr address, the so-called set bit is to write the bit as 1
• void clear_bit(nr, void *addr); //Clear the bit, clear the nrth bit of the addr address, the so-called clear bit is to write the bit to 0
• void change_bit(nr, void *addr);//Change the bit, invert the nrth bit of the addr address.
• test_bit(nr, void *addr);//Test bit, the above operation returns the nrth bit of the addr address.
• int test_and_set_bit(nr, void *addr);//Execute test_bit, then execute set_bit
• int test_and_clear_bit(nr, void *addr);//Execute test_bit, then execute clear_bit
• int test_and_change_bit(nr, void *addr);//Execute test_bit, then execute change_bit