Arm rtx Operating System & mdash; Overview & mdash; Product Description, rtxoverview

Arm rtx Operating System-Overview-Product Description, rtxoverview
Product Description

The RTX Kernel provides basic functions for creating and canceling task processes. The RTX kernel also provides some additional functions for communication between task processes. With these communication functions, You can synchronize task processes, manage common resources (such as peripherals or memory) of the system, and transmit messages between task processes.

Developers can set the scheduling priority of task processes.

The RTX Kernel provides the following task process communication functions:

1. Event flags)

The event flag is the primary means to synchronize task processes. Each task process has 16 event flags. Therefore, each task process can wait for 16 events or some of them to occur and then process them.

The event flag of a task process can be set by other task processes or ARM interrupt programs. You can synchronize external asynchronous events with the RTX kernel by using the event flag location in the ARM interrupt program.

To put it simply, it is the placement flag of other task processes or interrupt programs, and the current task process chooses to wait for a task flag. If a flag is located, it indicates that something has happened, so the current process can complete the corresponding work according to the meaning of the event flag.

 

2. Semaphores)

When multiple tasks need to access a public resource at the same time, competition will occur. Competition will result in cross-Access of multiple processes, making the system's public resources abnormal.

Semaphores (Binary semaphores) are the main means to solve this problem. Semaphores ensure that only one task process accesses public resources at a time.

The specific implementation of the RTX kernel is as follows:

Semaphores are an object implemented by the software. This object contains a virtual token. The RTX kernel grants this token to the task process that requests the public resources for the first time. When another task process requests this public resource again, the current token is not released to the semaphore, And the RTX kernel is set to sleep for waiting. Until the first task process releases the token, the token is returned to the semaphore by the rtx kernel, and other task processes are immediately placed in the ready list by the RTX kernel to prepare for running.

The RTX kernel also provides a timeout mechanism to place the task process in sleep state permanently because of waiting for a semaphore.

 

Mutexes)

Mutex lock is also one of the solutions to competition and memory access problems.

A mutex lock is an object implemented by the software. A task process can use it to lock a public resource. Only the task process that locks the public process has a lock and can access the corresponding public resources. Other task processes cannot access public resources because they cannot be locked. The RTX kernel will always block the task processes that request mutex lock until the task processes that have the lock release the lock.

 

Mailboxes)

The mail box should be used to store messages.

Task processes can send messages to each other through email boxes ). This method is often used when creating some high-level protocols, such as TCP-IP, UDP, and ISDN.

A message is actually a pointer pointing to a memory area containing the message content. Task processes must dynamically create and release these memory areas to prevent memory leakage.

If the message has not arrived, the RTX kernel sets the task process waiting for the message to sleep. The kernel will wake up the task process as soon as possible when other task processes send messages.