CN1549108A - A Method for Realizing Zero-copy Message Queue in Communication Process - Google Patents

Abstract

The invention relates to a method for realizing a zero-copy message queue in a communication process. The zero-copy message queue is a circular buffer composed of pointers to message body data. Its data structure includes the head pointer, tail pointer, current number of messages, total number of messages in the message queue, and mutex operation semaphore , counting semaphores, etc. The invention overcomes the disadvantage of multiple memory copies in the message queue of the existing operating system, so as to ensure that there is no memory copy in the message communication process. It can be widely used in embedded operating systems. Through the comparison test with the VxWorks message queue, the communication rate has been greatly improved, and the memory occupation in the communication process has been reduced, saving valuable system resources. At the same time, because it supports multiple operating systems, it is beneficial to the transplantation of application programs built on various operating systems.

Description

A Method for Realizing Zero-copy Message Queue in Communication Process

technical field

The invention relates to a method for realizing communication between operating system tasks or threads, in particular to a method for realizing zero-copy message queue in the communication process, which is suitable for communication between embedded real-time operating system tasks through message queue communication.

Background technique

As the world economy enters the new era of digital economy, telecommunication technology and information network technology have achieved unprecedented rapid development. The huge change from the network to the business in the communication field is driving the continuous development of the data service, and the flow of the data service may exceed the flow of the voice service within 2 to 3 years.

The business based on data packet switching will cover the entire traditional telecommunication business within 5 to 10 years. Therefore, the communication mode of signaling flow in circuit switching of a single voice service is changed to the communication mode of protocol flow and signaling flow in data exchange of a large number of data services, the communication volume is greatly increased, and the communication rate is also increasing. The system transfers control flow data to put forward higher requirements.

Modern operating systems often communicate between tasks through messages. Message queues provide an advanced communication mechanism between tasks and are widely used in embedded systems. However, the message queue provided by the current operating system is in the process of message communication. In order to provide protection for the task context, the usual practice is to copy the message in the private space of the sending task to the system buffer, and then copy it from the system buffer to the receiving In the private space of the task, there are multiple copies of the message memory during the message sending and receiving process. On the one hand, it consumes a lot of system resources, and on the other hand, the communication efficiency is also greatly reduced.

1. In the embedded real-time operating system VxWorks, the system sends messages through the msgQSend() function and receives messages through the msgQReceive() function. When sending a message, when the receiving task is waiting for the message queue, it needs to go through a memory copy: the private space of the sending task to the private space of the receiving task. When the receiving task is not waiting for the message queue, it needs to go through two memory copies: from the private space of the sending task to the buffer of the system message queue; then from the message queue buffer to the private space of the receiving task. If the message to be sent is large, the stack space of the sending task and the receiving task must also be increased, otherwise it is easy to cause stack overflow.

2. In general-purpose operating systems such as Windows NT, the system sends asynchronous messages through the PostMessage() function, sends synchronous messages through the SendMessage() function, and receives messages through GetMessage() or PeekMessage(). In the windows program, when the application sends a message to notify the specified window to perform a task, the PostMessage() function creates a MSG message structure for the message and copies the message to the message queue, and the application sends the message through the message loop. The message is fetched (copied from the message queue to the local context) and dispatched to the corresponding window for processing. It can be seen that there are multiple memory copy problems in the message distribution process.

Furthermore, most of the applications in the communication field are based on message-driven, and the operations on message queues are very frequent. However, the calling interfaces of message queues provided by various operating systems are inconsistent, which makes the transplantation of application codes very inconvenient and poor in readability. very bad.

Contents of the invention

The purpose of the present invention is to overcome the shortcoming of multiple memory copies in the existing operating system message queue, and propose a method for realizing zero-copy message queue in the communication process, so as to ensure that there is no memory copy in the message communication process. The present invention supports urgent and common two-level messages, and provides multiple query interfaces, and can be widely used in embedded operating systems such as VxWorks, pSoS, and general-purpose operating systems Windows NT through the adaptation of semaphores and mutual exclusion mechanisms , Linux and other operating systems, shielding the differences of various operating systems.

The present invention is achieved like this:

A method for implementing a zero-copy message queue in a communication process, comprising the steps of:

The first step is semaphore adaptation: create, acquire, release, and delete a semaphore common to various operating systems, including vxworks, pSos, Windows NT, Linux and other operating systems.

Step 2 Mutex adaptation: Create, acquire, release, and delete a mutex common to various operating systems, including vxworks, pSos, Windows NT, Linux and other operating systems.

The third step is to initialize the system message queue pool: when the system is initialized, a message queue pool is allocated in the system buffer to create the index information of the entire message queue.

Step 4 Create a message queue: Find an unallocated message queue from the message queue pool, and return the number of the message for sending and receiving messages.

Step 5 Send a message: Send message data on the specified message queue. If it is an urgent message, add the message to the head of the message queue. For ordinary messages, add the message to the end of the message queue, and finally return success or failure.

Step 6 Receive the message: Receive the message on the specified message queue and return the pointer to the receive buffer. If the message queue is empty: when the timeout parameter is 0, a null pointer is returned immediately; when the timeout parameter is -1, the task enters the blocking queue and waits forever; when the timeout parameter is other values, the task delays for a period of time and continues to run. When the message queue is not empty, take a message from the head of the message queue and return it to the receive buffer.

The seventh step is to delete the message queue: the unused message queue needs to be deleted and the memory occupied by it should be released. Deleting a message queue is the reverse process of creating a message queue. It is judged whether the specified message queue ID number is in use. If it is not in use, the deletion will fail. If it is in use, the message memory in the message queue will be released and the message space will be cleared. number and set to unused.

Step 8 Query the number of messages: Obtain the message queue to be queried by inputting the index number, and return the number of messages in it.

Adopting the zero-copy message communication method described in the present invention, compared with the prior art, the communication rate is greatly improved by comparing with the VxWorks message queue, and the memory occupation in the communication process is reduced at the same time, saving valuable system resource. At the same time, because it supports multiple operating systems, it is beneficial to the transplantation of application programs built on various operating systems.

Description of drawings

Figure 1 shows the implementation of VxWorks message queue;

Figure 2 shows the implementation principle of zero-copy message queue;

Figure 3 shows the implementation process of the zero-copy message queue;

Figure 4 shows the process of creating a message queue;

Figure 5 shows the process of sending messages;

Figure 6 shows the process of receiving messages;

Figure 7 shows the process of deleting the message queue.

Detailed ways

Figure 1 introduces the implementation of the VxWorks message queue. When the message queue is initialized, a message queue is allocated and initialized in the system space. It pre-allocates enough buffer space with the maximum number of messages it can queue and the maximum byte length of each message. When the task and ISR call the msgQSend() function to send a message to the message queue, if no task is waiting for the message in the queue, then the message enters the buffer of the message queue. If there are tasks waiting for a message on the queue, the message is immediately submitted to the first waiting task. When the message queue is full, that is, when the queue has no available buffers, the sending task waits for a certain timeout. When the timeout is NO_WAIT(0), the sending task returns an error immediately. When the timeout is WAIT_FOREVER(-1), the sending task enters the blocking task queue. When the timeout is other, the sending task is delayed for a period of time before continuing to run. The task calls the msgQReceive() function to receive messages from the message queue. If there are already messages available in the queue buffer, the first message is dequeued immediately and returned to the caller. If no message is available, the caller will block and be enqueued in the task queue waiting for the message. It can be seen that in VxWorks, when sending a message, when the receiving task is waiting for the message queue, it needs to go through a memory copy: from the private space of the sending task to the private space of the receiving task. When the receiving task is not waiting in the message queue, it needs to go through two memory copies: from the private space of the sending task to the buffer of the system message queue; then from the message queue buffer to the private space of the receiving task.

Figure 2 introduces the implementation principle of the zero-copy message queue. The zero-copy message queue is a circular buffer composed of pointers to message body data. Its data structure includes the head pointer, tail pointer, current number of messages, total number of messages in the message queue, and mutex operation semaphore , counting semaphores, etc. When the system is initialized, a message queue pool is allocated in the system buffer to create the index information of the entire message queue. When a task creates a message queue for inter-task communication, it searches for an unallocated message queue from the message queue pool, and returns the number of the message, which is used for sending and receiving messages. When the message is sent, if it is an ordinary message, the pointer of the sending task data is attached to the tail of the current message queue, and if it is an urgent message, the pointer of the message data is added to the head of the message queue. If the boundary of the message queue is reached, the boundary pointer is adjusted. Release the semaphore waiting on the message queue after sending, that is, add 1 to the counting semaphore. When receiving a message, the receiving task takes out the pointer of the first message from the head of the queue, returns it to the receiving task buffer, and performs appropriate pointer operations at the same time. If the message queue is empty, receive and wait for the counting semaphore of the message queue, that is, decrement the counting semaphore by 1. If the counting semaphore is less than 0 at this time, perform corresponding processing according to the receive timeout value parameter. Since the pointer is passed in the sending and receiving process of the message, no memory copy is performed.

Figure 3 introduces the process of creating a message queue. First initialize the message queue pool. If the message queue pool has been initialized, the initialization function will not be called any more. After the initialization is complete, search for an unused message queue from the system message queue pool, if not found, return an index value of an illegal message queue; if find an unused message queue, initialize the value of the message queue, including Head pointer, tail pointer, number of messages, create mutex semaphore, create count semaphore, etc. Since this step is an operation on global data, a global semaphore is required for mutual exclusion. After the message queue is initialized, the index of the message queue is returned.

Figure 4 introduces the process of sending messages. Firstly, check the input parameters, output print information for illegal parameters and return sending failure. Then enter the key code segment protection: the key code segment protection can be realized by switch interrupt or semaphore, and adapted by macro switch. If it is an interrupt mutual exclusion, the lock is interrupted; if it is a semaphore mutual exclusion, take the semaphore. The next step is to operate the pointer of the queue: if it is an urgent message, add the message to the head of the message queue; if it is an ordinary message, add the message to the tail of the message queue. At the same time, the number of messages in the message queue is increased by 1. After the operation is completed, exit the key code segment protection: if it is interrupt mutual exclusion, open the interrupt lock. If the semaphore is mutually exclusive, release the semaphore. After the message is added to the message queue, the sending task needs to release the counting semaphore waiting on the message queue, and the counting semaphore is increased by 1 to make the blocked task ready and let the kernel run the scheduling core. Finally, it returns the success of sending the message.

Figure 5 describes the process of receiving messages. First, check the input parameters, and return a null pointer if the parameters are illegal. First obtain the pointer to operate the message queue, and then obtain the counting semaphore to decrement the counting semaphore by 1. If the counting semaphore is less than 0, the calling task will be processed according to the timeout parameter: when the timeout parameter is 0, return a null pointer immediately ; When the timeout parameter is -1, the task enters the blocking queue and waits forever; when the timeout parameter is other values, the task delays for a period of time and continues to run. When the calling task resumes running, if the message queue is empty, return a null pointer, otherwise perform core data operations: first enter the key code protection, then perform pointer operations, take a message from the head of the message queue, return it to the caller, and message queue The number of messages in the message is reduced by 1, and the key code protection is exited after the message is taken out. Finally return the retrieved message.

Figure 6 introduces the process of deleting a message queue. Deleting a message queue is the inverse process of creating a message queue. First, get the pointer to operate the message queue. If the message queue is not in use, return a deletion error. Otherwise, get the pointer to the message queue. Set the head pointer, tail pointer, number of messages, Set the equivalent value of the maximum number of messages to 0, and delete the mutex semaphore and waiting count semaphore at the same time. This operation needs to do mutual exclusion in the global data area. Finally, return delete successfully.

Figure 7 introduces the flow of how to implement the message queue solution. The flowchart implements the 8 steps of the scheme introduced above, namely, semaphore adaptation, mutex adaptation, message queue initialization, creation of message queue, sending message, receiving message, deleting message queue, querying message queue, etc.

Claims (12)

1. a method that realizes the communication process zero-copy message queue comprises the steps:

It is adaptive to carry out semaphore: create, obtain, discharge, delete one to the general semaphore of operating system;

It is adaptive to carry out mutex: create, obtain, discharge, delete one to the general mutex of operating system;

To the initialization of system message queue pond: during system initialization, in the system buffer, distribute a message queue pond, to create the index information of whole message queue;

Create message queue: from the message queue pond, search a still unappropriated message queue, return the numbering of this message, be used for the transmission and the reception of message;

Send message: on the message queue of appointment, send message data;

Receive message: on the message queue of appointment, receive message, and return the pointer of send buffer;

Deletion message queue: no message queue is needed deletion, and discharge the internal memory that it takies;

Query messages number: need to obtain the message queue of inquiry by the input call number, and return message count wherein.

2. realize the method for zero-copy message queue according to claim 1, it is characterized in that:

The described operating system that is common to institute's adaptation signal amount and mutex comprises vxworks, pSos, Windows NT, Linux etc.

3. realize the method for zero-copy message queue according to claim 1, it is characterized in that: described transmission message:

Be urgent message, add this message to the message queue head;

Be common message, add this message to the message queue tail.

4. realize the method for zero-copy message queue according to claim 1, it is characterized in that:

The message queue of described reception message is for empty: timeout parameter is 0, returns null pointer immediately; Timeout parameter is-1, and task enters the obstruction formation and forever waits for; Timeout parameter is other value, and task postpones a period of time and continues operation,

The message queue non-NULL of described reception message takes out a message and turns back to send buffer from the message queue head.

5. realize the method for zero-copy message queue according to claim 1, it is characterized in that:

Described deletion message queue is used to judge whether the specify message formation is used for ID number,

If do not use, the deletion failure;

If use, the message internal memory in this message queue is discharged, the flush message number, and be set to not use.

6. realize the method for zero-copy message queue according to claim 1, it is characterized in that:

Described message queue is a cyclic buffer of being made up of the pointer of refer message volume data, and its data structure comprises total message number of head pointer, the tail pointer of message queue, current message number, message queue and mutually exclusive operation semaphore, counting semaphore etc.

7. as the method for realization zero-copy message queue as described in claim 1 or 3, it is characterized in that: described transmission message:

Be common message, the pointer that sends task data is articulated to the afterbody of current message queue;

Be urgent message, then the pointer of this message data added to the head of message queue;

Arrive the border of message queue, do border pointer adjustment;

Discharge the semaphore of waiting on this message queue after transmission finishes, promptly counting semaphore adds 1.

8. as the method for realization zero-copy message queue as described in claim 1 or 4, it is characterized in that: described reception message:

The reception task is taken out the pointer of first message from the message queue head, and it is returned to reception task buffer zone, makes suitable pointer operation simultaneously,

If message queue is empty, receive the counting semaphore of waiting for this message queue, promptly counting semaphore subtracts 1;

If counting semaphore is then handled according to the receive time-out value parameter accordingly less than 0 at this moment.

9. realize the method for zero-copy message queue according to claim 1, it is characterized in that: described establishment message queue further comprises the steps:

Initial message formation pond,

From the system message queue pond, search a still untapped message queue: do not find, then return the index value of an invalid message formation; Find a still untapped message queue, then the value of this message queue of initialization utilizes overall signal to measure mutual exclusion, comprises head pointer, tail pointer, message count, and create the mutex amount, create counting semaphore etc.,

Finish this message queue of initialization, the index of return messages formation.

10. realize the method for zero-copy message queue according to claim 1, it is characterized in that: described transmission message further comprises the steps:

Input parameter is carried out effect, and illegal parameter output print information is also returned to send and is failed,

Enter the key code segment protect: utilize switch interrupts or use semaphore, adaptive by macro switch, be to interrupt mutual exclusion, lock interrupts; Be the semaphore mutual exclusion, get semaphore,

Carry out the pointer operation of message queue: be urgent message, add this message to the message queue head; Be common message, add this message to the message queue tail, the message count in the message queue adds 1 simultaneously,

Withdraw from the key code segment protect: be to interrupt mutual exclusion, open and interrupt lock; Be the semaphore mutual exclusion, release semaphore,

After message was added message queue to, the transmission task need discharge the counting semaphore of wait on this message queue, and this counting semaphore adds 1, and it is ready that the obstruction task is entered, and allowed kernel traffic control core,

Return and send the message success.

11. realize the method for zero-copy message queue according to claim 1, it is characterized in that: described reception message further comprises the steps:

Input parameter is carried out effect, and the non-rule of parameter is returned null pointer,

Obtain the pointer of this message queue of operation, obtain counting semaphore then, make counting semaphore subtract 1, this counting semaphore is less than 0, and then calling task will be handled according to timeout parameter; Timeout parameter is 0, returns null pointer immediately; Timeout parameter is-1, and task enters the obstruction formation and forever waits for; Timeout parameter is other value, and task postpones a period of time and continues operation, and calling task resumes operation,

Message queue is empty, returns null pointer, otherwise carries out the core data operation: at first enter the key code protection; then carry out pointer operation, take out a message, return to caller from the message queue head; message count in the message queue subtracts 1 simultaneously, withdraws from the key code protection after the taking-up message

Return the message of taking-up.

12. realize the method for zero-copy message queue according to claim 1, it is characterized in that: described deletion message queue further comprises the steps:

Obtain the pointer of this message queue of operation, this message queue does not use, and then returns deletion error; Otherwise obtain the pointer of this message queue, do the mutual exclusion in global data district, head pointer, tail pointer, message count, maximum number of messages equivalence are set to 0, delete the mutex amount simultaneously, wait for counting semaphore;

Return and delete successfully.

Images