Atomic Operation
Basic Concepts
In an OS that supports multiple tasks, modifying data in a memory area requires three steps: read data, modify data, and write data. However, data in a same memory area may be simultaneously accessed by multiple tasks. If the data modification is interrupted by another task, the execution result of the operation is unpredictable.
Although you can enable or disable interrupts to ensure that the multi-task execution results meet expectation, the system performance is affected.
The ARMv6 architecture has introduced the LDREX and STREX instructions to support more discreet non-blocking synchronization of the shared memory. The atomic operations implemented thereby can ensure that the "read-modify-write" operations on the same data will not be interrupted, that is, the operation atomicity is ensured.
Working Principles
The OpenHarmony system has encapsulated the LDREX and STREX in the ARMv6 architecture to provide a set of atomic operation APIs.
-
LDREX Rx, [Ry]
Reads the value in the memory and marks the exclusive access to the memory segment.
- Reads the 4-byte memory data pointed by the register Ry and saves the data to the Rx register.
- Adds an exclusive access flag to the memory area pointed by Ry.
-
STREX Rf, Rx, [Ry]
Checks whether the memory has an exclusive access flag. If yes, the system updates the memory value and clears the flag. If no, the memory is not updated.
-
If there is an exclusive access flag, the system:
- Updates the Rx register value to the memory pointed to by the Ry register.
- Sets the Rf register to 0.
-
If there is no exclusive access flag:
- The memory is not updated.
- The system sets the Rf register to 1.
-
-
Flag register
- If the flag register is 0, the system exits the loop and the atomic operation is complete.
- If the flag register is 1, the system continues the loop and performs the atomic operation again.
Development Guidelines
Available APIs
The following table describes the APIs available for the OpenHarmony LiteOS-A kernel atomic operation module. For more details about the APIs, see the API reference.
Table 1 Atomic operation APIs
How to Develop
When multiple tasks perform addition, subtraction, and swap operations on the same memory data, use atomic operations to ensure predictability of results.
NOTE: Atomic operation APIs support only integer data.
Development Example
Example Description
Call the atomic operation APIs and observe the result.
-
Create two tasks.
- Task 1: Call LOS_AtomicInc to add the global variables 100 times.
- Task 2: Call LOS_AtomicDec to subtract the global variables 100 times.
-
After the subtasks are complete, print the values of the global variables in the main task.
Sample Code
The sample code is as follows:
#include "los_hwi.h"
#include "los_atomic.h"
#include "los_task.h"
UINT32 g_testTaskId01;
UINT32 g_testTaskId02;
Atomic g_sum;
Atomic g_count;
UINT32 Example_Atomic01(VOID)
{
int i = 0;
for(i = 0; i < 100; ++i) {
LOS_AtomicInc(&g_sum);
}
LOS_AtomicInc(&g_count);
return LOS_OK;
}
UINT32 Example_Atomic02(VOID)
{
int i = 0;
for(i = 0; i < 100; ++i) {
LOS_AtomicDec(&g_sum);
}
LOS_AtomicInc(&g_count);
return LOS_OK;
}
UINT32 Example_AtomicTaskEntry(VOID)
{
TSK_INIT_PARAM_S stTask1={0};
stTask1.pfnTaskEntry = (TSK_ENTRY_FUNC)Example_Atomic01;
stTask1.pcName = "TestAtomicTsk1";
stTask1.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
stTask1.usTaskPrio = 4;
stTask1.uwResved = LOS_TASK_STATUS_DETACHED;
TSK_INIT_PARAM_S stTask2={0};
stTask2.pfnTaskEntry = (TSK_ENTRY_FUNC)Example_Atomic02;
stTask2.pcName = "TestAtomicTsk2";
stTask2.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
stTask2.usTaskPrio = 4;
stTask2.uwResved = LOS_TASK_STATUS_DETACHED;
LOS_TaskLock();
LOS_TaskCreate(&g_testTaskId01, &stTask1);
LOS_TaskCreate(&g_testTaskId02, &stTask2);
LOS_TaskUnlock();
while(LOS_AtomicRead(&g_count) != 2);
PRINTK("g_sum = %d\n", g_sum);
return LOS_OK;
}
Verification
g_sum = 0