When processing the real-time collected and updated data, it often encounters the problem that the data update speed does not match the data processing speed. In this case, there will be data loss, resulting in inaccurate data processing results, and even unpredictable consequences. Therefore, a mechanism is needed to coordinate data update and data processing to ensure the integrity of the data and the accuracy of the processing results. Sex. As a multi-tasking, multi-user operating system, Linux supports multiple processes running concurrently in the system. Due to the dynamic characteristics of the process itself, it is very suitable to describe real-time data processing. Therefore, it is necessary to solve the synchronization and communication problems between Linux processes. Can solve the problem of real-time data processing.
In the Linux environment, a process usually has four states: running, blocked, ready, and terminated. When multiple processes are executed concurrently, race conditions between processes often occur. We hope that processes can coordinate their behaviors so that a process will only perform an action when other processes reach a specific point, that is, control synchronization; at the same time, there should be no race conditions when concurrent processes access shared data. This is ensured by performing mutual exclusion when accessing shared data, that is, data access synchronization.
The basic technology to achieve synchronization is to block a process until a specific condition is met; to achieve data access synchronization is to block a process until another process finishes accessing shared data.
1 Producer-consumer problem model of finite-length bufferWhen there is only a single producer and consumer, the production process and the consumption process correspond to the same data structure, and they share the same data space. How to coordinate the production process and the consumption process so that the data used by the consumption process each time is written by the new production process, and the data newly written by the production process will not overwrite the data that has not been read and used by the consumption process , Is the key issue in the realization of the problem model.
In the producer-consumer problem model, the producer process continuously produces products and puts them into the buffer, and the consumer process continuously takes the products from the buffer for consumption. When the product in the buffer zone is full, it means that the production rate is higher than the consumption rate, and there is an oversupply. At this time, the producer must wait for the product to be consumed; when the buffer zone is empty, it means that the consumption rate is higher than the production rate and there is a shortage of demand. At this time, the consumer process must wait for the production of the product. The processes of production and consumption must be synchronized to achieve a balance between supply and demand.
Two common strategies for dealing with read and write synchronization are called "strong reader synchronization" and "strongwriter synchronization". In strong reader synchronization, readers are always given priority, as long as the writer is not currently writing, the reader can get access; in strong writer synchronization, the writer always gets priority, as long as the strong reader does not currently have For read operations, writers can gain access. The producer-consumer synchronization is different from pure read-write synchronization. Consumers can delete or destroy resources by accessing resources.
A producer-consumer problem model with a limited-length buffer is composed of a number of producer and consumer processes and a limited buffer pool. Each buffer can store one information record, and one producer produces one information record at a time. After a record is generated, it waits to enter an empty buffer separately and then writes the record into the buffer. A consumer process consumes one information record at a time. When it needs to consume, it waits to enter a full buffer and reads the record.
From the above description, it can be concluded that the solution to the producer-consumer problem model needs to meet the following conditions:
â—‡The producer should not cover a full buffer zone;
â—‡Consumers should not use an empty buffer;
â—‡ Producers and consumers should access the data buffer in a mutually exclusive manner;
â—‡Data must follow the first-in first-out (FIFO) method;
â—‡ Busy waiting cannot occur.
The data writing process must avoid constantly and repeatedly checking the buffer until it finds an empty buffer, and the reading process must also avoid constant checking until it finds a full buffer. This is equivalent to busy waiting in the system, which is an unavoidable problem when only the critical section (CS) algorithm is used to achieve process synchronization.
In view of the constraints of the problem model solution, the semaphore method is used to solve the process synchronization problem of real-time update data processing, that is, the above-mentioned producer-consumer problem model.
The semaphore is a non-negative shared integer value and can only be used for initialization and indivisible operations. Indivisible operation refers to an operation that cannot overlap with any other operation on D when an operation is performed on a data D. Define operations P and V as inseparable operations. The inseparability of P and V means that these operations cannot be executed concurrently, avoiding race conditions for semaphores. The operational semantics of P and V are defined as:
Judging from the semantics defined above, for the operation of a semaphore S, P and V are to change the value of S, or to suspend or wake up a process that performs P operation on S. The suspended process is blocked, thus avoiding the busy waiting problem. A binary semaphore only takes 0 and 1 to achieve mutual exclusion.
In P and V operations, blocking and waking up the process requires the participation of the process management component of the operating system, so the semaphore will be implemented by the operating system instead of the application.
Producer-consumer problem model description:
The implementation of the producer-consumer problem model with limited buffers includes the following components: shared data-buffer group, operation-buffer access, process-producer-consumer.
In producer-consumer synchronization, the resource is created by the producer. Unlike a simple reading program, the consumer can delete or destroy the resource by accessing the resource. Since the producer process and the consumer process share a buffer, they must be synchronized when inserting and deleting entries. In the implementation, the synchronization exceptions listed in Table 1 must be avoided.
The traditional semaphore solution to the producer-consumer problem uses two semaphores to indicate the number of entries in the buffer and the number of free slots. When a process needs a specific type of resource, it can decrement the corresponding semaphore through a function call; similarly, when the process releases resources, it can increment the corresponding semaphore through a function call. Since the semaphore never drops below zero, the process cannot use non-existent resources. Therefore, always initialize the counting semaphore to the number of resources available at the beginning.
Define the circular queue buffer to store the data to be processed, and the console data processing process consumes data from the circular queue buffer and marks the data storage bit as "abandoned". The data acquisition and writing process can only store data in the circular queue buffer marked as "abandoned", as shown in Figure 1.
In the absence of multiple producers or consumers, if implemented carefully, the circular buffer does not need locks. The producer is the only process that is allowed to modify the write index and the array position pointed to by the index. As long as the writer saves the new value to the buffer before updating the write index, the reader will always see a consistent data structure; at the same time, the reader is the only one who can access the read index and the location that the index points to The process of data. As long as the two pointers do not overlap each other, the producer and consumer can access the buffer without a race condition, as shown in Figure 2.
For only a single producer and consumer, it is realized by using a modified producer-consumer problem model solution using semaphore.
The above uses the semaphore method to solve the priority buffer problem. The semaphore "empty" and "full" values ​​indicate the number of empty and full buffers respectively, as shown in Figure 3. The buffer pointers i and j are used to ensure that the buffer is provided and used in a first-in, first-out order. As long as there are some full and empty buffers in the system, the data update process and the data processing process can be executed concurrently without competition. The author successfully implemented the use case test on the Huaheng ARM embedded platform HHARM2410-R5 according to the above scheme.
The above structural design simplifies the producer and consumer into one. When there are multiple producers and consumers, based on the above-mentioned modified solution, multiple counters can be designed to count parallel readers (readers), parallel writers (writers), readers or readers (pre_reader), and writers. The number of writers or pre_writers. The value of the counter is increased or decreased at the corresponding position in the process. Readers and writers must be blocked before they are allowed to read and write. This can be done through the P operation. When the reader or writer is blocked in the process, the conditions that control the start of reading or writing are not met. These conditions change with the change of any counter value, so the process must perform the corresponding V operation after finishing reading or writing.
When implementing the multi-read and multi-write process synchronization solution, it is necessary to avoid the race conditions of different counters, and therefore, it is necessary to perform a check on the allowable read or write operation conditions in the critical section (CS).
Ningbo Autrends International Trade Co.,Ltd. , https://www.supermosvape.com