WO2015089839A1

WO2015089839A1 - Method and device for processing messages in shared queue and receiving core

Info

Publication number: WO2015089839A1
Application number: PCT/CN2013/090139
Authority: WO
Inventors: 宁科; 陶维华
Original assignee: 华为技术有限公司
Priority date: 2013-12-20
Filing date: 2013-12-20
Publication date: 2015-06-25
Also published as: CN105264499B; CN105264499A

Abstract

The invention is applicable in the technical field of message processing, and provides a method and a device for processing messages in a shared queue and a receiving core. The method comprises the following steps: an interrupt handler in the receiving core receiving an interrupt notification message transmitted by the shared queue; the interrupt handler reading a reserved message number; the interrupt handler judging the read reserved message number; if the reserved message number is 0, messages having been occupied by other receiving core, a service thread being not awakened, and the interrupt handler directly exiting; if the reserved message number is non-0, messages being reserved successfully, the service thread being awakened, and the service thread reading the messages from the shared queue. The invention avoids awakening of invalid service threads when a plurality of receiving cores share a queue so as to reduce time delay, and the service thread can process the messages of a fixed number more than 1 under a shared queue message processing scenario of multiple receiving ends.

Description

Message processing method, device and receiving core in shared queue

Technical field

The present invention belongs to the field of message processing technologies, and in particular, to a message processing method, apparatus, and receiving core in a shared queue.

Background technique

Shared messages are typically used in multi-threaded multicore to speed up thread or inter-core communication. One of the widely used scenarios is a sender and multiple receivers. The message data can be received by any one of the cores, and there is a competition relationship between the plurality of receiving cores.

Please refer to FIG. 1 , which is a shared queue message processing scenario of multiple receiving ends. The general processing procedure is as follows. The scenario assumes two receiving cores:

Step 1: The sending core writes the message data to the shared queue;

Step 2: The shared queue generates an event interrupt to notify all relevant receiving cores;

Step 3: The interrupt handler in the receiving core processes the interrupt, judges according to the information such as the queue number, and schedules the corresponding service thread 0 or 1 to read the message data from the shared queue;

Step 4: Both service threads 0 and 1 competingly read messages from the shared queue. In this way, one business thread can read the message, and another business thread can not read the message. Business threads that do not read the message will exit without doing anything.

It can be seen from the above that due to the reason of message sharing, there will be wake-up of invalid business threads in the whole process. When the number of messages is relatively large, the efficiency of the core is very low. In addition, the business thread cannot handle the fixed more than 1 each time it wakes up. The number of messages. For example, if two messages are fixedly processed after each wakeup, each of the two messages in the shared queue generates an interrupt. When one message is read, another message may be read by another thread.

technical problem

The object of the present invention is to provide a message processing method, device and receiving core in a shared queue, which aims to solve the problem of message sharing in the prior art, and there is an invalid service thread wake-up in the whole process, when the message is compared. Many times, the core is running very inefficiently; in addition, the business thread cannot handle more than 1 fixed message per wake-up. For example, if two messages are fixedly processed after each wakeup, each of the two messages in the shared queue generates an interrupt. When one message is read, there is a possibility that another message is read by another thread.

Technical solution

The present invention is implemented as a message processing method in a shared queue, the method comprising the following steps:

The interrupt handler in the receiving core receives the interrupt notification message sent by the shared queue;

The interrupt handler reads the number of subscription messages;

The interrupt handler determines the number of subscribed subscription messages;

If it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not woken up, and the interrupt processing program directly exits;

If it is determined that the number of subscription messages is non-zero, the message subscription is considered successful, the service thread is woken up, and the service thread reads the message from the shared queue.

Another object of the present invention is to provide a message processing apparatus in a shared queue, the apparatus comprising:

a receiving module, configured to receive an interrupt notification message sent by the shared queue;

a reading module for reading the number of subscription messages;

a judging module, configured to determine the number of read subscription messages;

The wake-up control module is configured to: if it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not awake, the interrupt processing program directly exits; if it is determined that the number of subscription messages is non-zero, The message subscription is considered successful, waking up the business thread, and the business thread reads the message from the shared queue.

Another object of the present invention is to provide a receiving core including the message processing apparatus in the shared queue described above.

Beneficial effect

In the present invention, after the interrupt of the core is triggered, whether the corresponding task is activated is determined by whether the message subscription is successful. When a plurality of receiving cores share a queue, the waking of the invalid service thread is avoided, and the delay is reduced. In addition, the service thread can process a fixed number of messages greater than 1 in the shared queue message processing scenario of the multiple receiving ends.

DRAWINGS

FIG. 1 is a schematic diagram of a process flow of a shared queue message provided by the prior art.

2 is a schematic flowchart of an implementation process of a message processing method in a shared queue according to an embodiment of the present invention.

FIG. 3 is a schematic structural diagram of a message processing apparatus in a shared queue according to an embodiment of the present invention.

Embodiments of the invention

The present invention will be further described in detail below with reference to the accompanying drawings and embodiments. It is understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

Referring to FIG. 2, an implementation flow of a message processing method in a shared queue according to an embodiment of the present invention includes the following steps:

In step S101, the interrupt handler in the receiving core receives the interrupt notification message sent by the shared queue;

As an embodiment of the present invention, before step S101, the method further includes the following steps:

A counter that presets the number of subscribed messages in the shared queue.

In step S102, the interrupt handler reads the number of subscription messages;

In an embodiment of the invention, the interrupt handler reads the number of subscription messages from the counter.

In step S103, the interrupt processing program determines the number of read subscription messages;

In step S104, if it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not awake, and the interrupt processing program directly exits;

In step S105, if it is determined that the number of subscription messages is non-zero, the message subscription is considered successful, the service thread is woken up, and the service thread reads the message from the shared queue.

In the embodiment of the present invention, it is assumed that the total number of messages in the shared queue is total_num, the threshold of the number of messages that trigger the interruption is msg_threshold, and the number of the reserved messages is msg_rsv_num, and the calculation steps of the number of reserved messages are specifically:

In step S201, the service thread reads the number of reservation messages in the shared queue, msg_rsv_num, and the shared queue determines the total number of messages total_num-the number of messages that trigger the interruption, the number of msg_threshold-the number of subscription messages, msg_rsv_num, is greater than or equal to 0, if If it is greater than or equal to 0, the value of msg_rsv_num is calculated, msg_rsv_num=msg_rsv_num+msg_threshold, and the shared queue returns the calculated value of msg_rsv_num to the service thread; and the process proceeds to step S202. If less than 0, the value of the number of subscribed messages in the counter is unchanged, and the shared queue returns a value of 0 to the business thread.

In step S202, the service thread reads the message in the shared queue, and the shared queue determines whether msg_rsv_num is greater than 0. If it is greater than 0, the value of msg_rsv_num is updated, msg_rsv_num=msg_rsv_num-1.

Embodiments of the present invention can be applied to LTE In CoMP, the sRIO data reception completion message can be sent to the shared queue; other cores receive the shared message at the lowest priority (higher priority than the IDLE task). After the interrupt of the core is triggered, whether the corresponding task is activated is determined by whether the message subscription is successful.

Please refer to FIG. 3, which is a message processing device in a shared queue according to an embodiment of the present invention. For convenience of description, only parts related to the embodiment of the present invention are shown. The message processing device in the shared queue includes: a receiving module 101, a reading module 102, a determining module 103, and a wakeup control module 104. The message processing device in the shared queue may be a software unit, a hardware unit, or a combination of software and hardware built in the receiving core.

The receiving module 101 is configured to receive an interrupt notification message sent by the shared queue.

The reading module 102 is configured to read the number of subscription messages;

The determining module 103 is configured to determine the number of the read subscription messages;

The wake-up control module 104 is configured to: if it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not awake, the interrupt processing program directly exits; if it is determined that the number of subscription messages is non-zero , the message subscription is considered successful, the business thread is woken up, and the business thread reads the message from the shared queue.

In an embodiment of the invention, the apparatus further includes: a setting module.

A setup module that sets a counter for the number of subscription messages in the shared queue.

In the embodiment of the present invention,

The reading module 102 is specifically configured to read the number of subscription messages from the counter.

In an embodiment of the invention, the apparatus further includes: a subscription message number reading module, a numerical judgment module, a calculation module, a control module, and an update module.

a subscription number reading module for reading the number of subscription messages in the shared queue msg_rsv_num;

The value judging module is configured to determine whether the total number of messages total_num-the number of messages triggering the interrupt threshold msg_threshold-the number of the reserved message number msg_rsv_num is greater than or equal to 0,

a calculation module, configured to calculate a value of msg_rsv_num if it is judged to be greater than or equal to 0, msg_rsv_num=msg_rsv_num+msg_threshold;

The control module is configured to control the shared queue to return the calculated value of msg_rsv_num to the service thread; if less than 0, the value of the number of subscription messages in the counter is unchanged, and the control shared queue returns a value of 0 to the service thread.

The update module is configured to read the message in the shared queue, and the shared queue determines whether msg_rsv_num is greater than 0. If greater than 0, the value of msg_rsv_num is updated, msg_rsv_num=msg_rsv_num-1.

In summary, in the embodiment of the present invention, after the interrupt of the core is triggered, whether the corresponding task is activated is determined by whether the message subscription is successful. When a plurality of receiving cores share a queue, the waking of the invalid service thread is avoided, and the delay is reduced. In addition, the service thread can process a fixed number of messages greater than 1 in the shared queue message processing scenario of the multiple receiving ends.

One of ordinary skill in the art can understand that all or part of the steps of implementing the above embodiments may be completed by a program instructing related hardware, and the program may be stored in a computer readable storage medium, the storage. Media, such as ROM/RAM, disk, CD, etc.

The above is only the preferred embodiment of the present invention, and is not intended to limit the present invention. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present invention should be included in the protection of the present invention. Within the scope.

Claims

A message processing method in a shared queue, characterized in that the method comprises the following steps:

The interrupt handler in the receiving core receives the interrupt notification message sent by the shared queue;

The interrupt handler reads the number of subscription messages;

The interrupt handler determines the number of subscribed subscription messages;

If it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not woken up, and the interrupt processing program directly exits;

If it is determined that the number of subscription messages is non-zero, the message subscription is considered successful, the service thread is woken up, and the service thread reads the message from the shared queue.
The method according to claim 1, wherein before the step S101 of receiving the interrupt notification message sent by the shared queue by the interrupt handler in the receiving core, the method further comprises the following steps:

A counter that presets the number of subscribed messages in the shared queue.
The method of claim 2, wherein the step of the interrupt handler reading the number of subscription messages is specifically:

The interrupt handler reads the number of subscription messages from the counter.
The method of claim 1, wherein the calculating step of the number of subscription messages is specifically:

The service thread reads the number of subscription messages in the shared queue msg_rsv_num, the shared queue determines the total number of messages total_num-the number of messages that trigger the interrupt threshold msg_threshold- whether the value of the number of subscription messages msg_rsv_num is greater than or equal to 0, if greater than or equal to 0, then Calculate the value of msg_rsv_num, msg_rsv_num=msg_rsv_num+msg_threshold, the shared queue returns the calculated value of msg_rsv_num to the business thread; the business thread reads the message in the shared queue, and the shared queue determines whether msg_rsv_num is greater than 0. If it is greater than 0, the msg_rsv_num is updated. Value, msg_rsv_num=msg_rsv_num-1;

If the total number of messages total_num-triggered message threshold threshold msg_threshold-the number of subscription messages msg_rsv_num is less than 0, the value of the number of subscription messages in the counter is unchanged, and the shared queue returns a value of 0 to the service thread.
A message processing device in a shared queue, the device comprising:

a receiving module, configured to receive an interrupt notification message sent by the shared queue;

a reading module for reading the number of subscription messages;

a judging module, configured to determine the number of read subscription messages;

The wake-up control module is configured to: if it is determined that the number of subscription messages is 0, the message is considered to have been preempted by other receiving cores, and the service thread is not awake, the interrupt processing program directly exits; if it is determined that the number of subscription messages is non-zero, The message subscription is considered successful, waking up the business thread, and the business thread reads the message from the shared queue.
The device of claim 5, wherein the device further comprises:

A setup module that sets a counter for the number of subscription messages in the shared queue.
The device of claim 6 wherein:

The reading module is specifically configured to read the number of subscription messages from the counter.
The device of claim 5, wherein the device further comprises:

a subscription number reading module for reading the number of subscription messages in the shared queue msg_rsv_num;

The value judging module is configured to determine whether the total number of messages total_num-the number of messages triggering the interrupt threshold msg_threshold-the number of the reserved message number msg_rsv_num is greater than or equal to 0,

a calculation module, configured to calculate a value of msg_rsv_num if it is judged to be greater than or equal to 0, msg_rsv_num=msg_rsv_num+msg_threshold;

The control module is configured to control the shared queue to return the calculated value of msg_rsv_num to the service thread; if less than 0, the value of the number of subscription messages in the counter is unchanged, and the control shared queue returns a value of 0 to the service thread.

The update module is configured to read the message in the shared queue, and the shared queue determines whether msg_rsv_num is greater than 0. If greater than 0, the value of msg_rsv_num is updated, msg_rsv_num=msg_rsv_num-1.
A receiving core comprising the message processing apparatus in the shared queue of any one of claims 5 to 8.