WO2011023106A1

WO2011023106A1 - Scheduling method and scheduler for multi-core processor messages

Info

Publication number: WO2011023106A1
Application number: PCT/CN2010/076335
Authority: WO
Inventors: 杨炼
Original assignee: 华为技术有限公司
Priority date: 2009-08-25
Filing date: 2010-08-25
Publication date: 2011-03-03
Also published as: CN101634956B; CN101634956A

Abstract

A method for multi-core processor message scheduling is provided. The method includes: creating a message control block for a message, wherein the message control block records the description information and the scheduling control information of the message; creating a message reflection of the message, wherein the message reflection points to the message control block; inserting the message reflection into the message reflection queue of a sink task. A scheduler for multi-core processor messages is also provided. The disclosed solution enables high speed message transmission while requiring no additional memory, reducing memory cost and improving message transmission efficiency.

Description

Multi-core processor message scheduling method and scheduler. The present application claims priority to Chinese Patent Application No. 200910171233.7, entitled "Multi-core Processor Message Scheduling Method and Scheduler", filed on August 25, 2009, The entire contents are incorporated herein by reference. Technical field

The present invention relates to the field of computer and communication technologies, and in particular, to a multi-core processor scheduling method and a scheduler. Background technique

In a multi-core processor system, each core has a shared memory space. Memory buffers are entities that pass messages between tasks and between cores. In order to ensure that the first transmitted message is received first, the buffer that carries the message is usually designed as a queue structure that is connected in tandem. A queue of such buffers is called a message queue.

As a frequently used system function, the efficiency of message transfer greatly affects the operating efficiency of multi-tasking embedded systems. This effect is reflected in the time and memory overhead of the message scheduling process. The time overhead includes the execution time of the message scheduling function operation message queue, and the task switching time caused by the task entering and exiting the blocking state because the message is sent in a blocking manner. After the message is sent and received, the corresponding data is temporarily stored in the buffer of the message queue. The memory overhead refers to the memory space occupied by the message queue. The length of the message queue and the size of each buffer in the queue determine the memory overhead of the message scheduling function.

It can be seen that the management of message queue greatly affects the efficiency of message delivery, and is an important issue faced by message scheduling technology.

In the prior art, mailboxes and message pools are a general method for implementing message scheduling. The mailbox method organizes the message queue with a static buffer to implement message scheduling; the message pool method uses a dynamic buffer allocation mechanism to implement message scheduling.

Because the prior art implements message scheduling, it needs to perform a large number of repetitions in the messaging process. The data copy operation results in a large time overhead, and also causes the message broadcast and message forwarding process to require additional memory to store new messages, resulting in wasted memory resources and thus failing to provide a more efficient message scheduling function for the multi-core processor. Summary of the invention

An embodiment of the present invention provides a multi-core processor message scheduling method, which is used to improve the efficiency of message delivery. The method includes:

Generating a message control block of the message, the message control block recording description information of the message and scheduling control information;

Generating a message image of the message, the message image pointing to the message control block; adding the message image to a sink task message image queue corresponding to the message.

The embodiment of the present invention further provides a multi-core processor message scheduling method, which is used to improve the efficiency of message delivery, and the method includes:

Extracting a message image of the message from a sink task message image queue corresponding to the received message; and, according to the message control block pointed to by the message image, feeding back the description information of the message and the scheduling control information to the sink task.

The embodiment of the present invention further provides a multi-core processor message scheduler, which is used to improve the efficiency of message delivery. The multi-core processor message scheduler includes:

a first generation module, a message control block for generating a message, where the message control block records description information and scheduling control information of the message;

a second generating module, configured to generate a message image of the message, where the message image points to the message control block;

And adding a module, configured to add the message image to a sink task message image queue corresponding to the message.

An extracting module, configured to extract a message image of the message from the sink task message image queue; a feedback module, configured to feed back, according to the message control block pointed by the message image, the description information and the scheduling control information of the message to the sink task . In the embodiment of the present invention, the message image constituting the message queue is separated from the message control block for describing and controlling the message. When the message is sent, it is not necessary to copy the message control block and the data buffer, but only the message image and the message are generated. The image is added to the message image queue of the corresponding sink task; when receiving the message, only the message image of the message needs to be extracted from the sink task message image queue, and the description information of the message is fed back to the sink task according to the message control block pointed to by the message image and Scheduling control information; thus, in the messaging process, high-speed transmission of messages can be realized without repeated data copying operations, and no additional memory is needed, which can save memory overhead and improve message transmission efficiency. BRIEF DESCRIPTION OF THE DRAWINGS The accompanying drawings, which are set forth in the description of the claims Other drawings may also be obtained from these drawings without the inventive labor. In the drawing:

1 and FIG. 2 are flowcharts showing a process of a multi-core processor message scheduling method according to an embodiment of the present invention; FIG. 3 is a schematic diagram of an implementation scenario of a multi-core processor message scheduling method according to an embodiment of the present invention; Schematic diagram of memory management example;

FIG. 5 is a flowchart of detailed operations of a message creation process according to an embodiment of the present invention;

6 is a flowchart showing a detailed operation of a scheduler in an execution part of a kernel to which a source task belongs in a message sending process according to an embodiment of the present invention;

7 is a flowchart showing the detailed operation of the execution part of the kernel to which the scheduler belongs in the message sending process in the message sending process according to the embodiment of the present invention;

FIG. 8 is a flowchart of detailed operations of a scheduler in an execution part of a core to which a source task belongs in a synchronization message sending process according to an embodiment of the present invention; FIG.

FIG. 9 is a flowchart of detailed operations of an execution part of a kernel to which a scheduler belongs in a synchronization message during a synchronization message transmission according to an embodiment of the present invention;

FIG. 10 is a flowchart showing a detailed operation of a scheduler in an execution part of a core to which a source task belongs in a process of sending a synchronization response message according to an embodiment of the present invention; FIG.

FIG. 11 is a flowchart of a scheduler in a process of sending a synchronization response message according to an embodiment of the present invention; Detailed operational flow chart of the execution part of the kernel;

FIG. 12 is a flowchart of detailed operations of a message receiving process according to an embodiment of the present invention;

FIG. 13 is a flowchart of detailed operations of a message release process according to an embodiment of the present invention;

14 and FIG. 15 are schematic diagrams showing the structure of a multi-core processor message scheduler according to an embodiment of the present invention. detailed description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention more clearly, the embodiments of the present invention are further described in detail below. The illustrative embodiments of the present invention and the description thereof are intended to be illustrative of the invention, and are not intended to limit the invention.

As shown in FIG. 1, the processing flow of the multi-core processor message scheduling method in the embodiment of the present invention may include:

Step 101: Generate a message control block of the message, where the message control block records the description information of the message and the scheduling control information.

Step 102: Generate a message image of the message, where the message image points to the message control block;

Step 103: Add the message image to the sink task message image queue.

In the flow shown in Figure 1, the message image that constitutes the message queue is separated from the message control block that describes and controls the message. When sending the message, there is no need to copy the message control block and the data buffer, but only the message image is generated. The message image is added to the message image queue of the corresponding sink task, so that the message transmission process does not need to perform repeated data copy operations, and the message can be sent at a high speed without using extra memory, which can save memory overhead and improve the efficiency of message transmission.

As shown in FIG. 2, the processing flow of the multi-core processor message scheduling method in the embodiment of the present invention may include:

Step 201: Extract (ie, dequeue) the message image of the message from the sink task message image queue. Step 202: Feed back, according to the message control block pointed to by the message image, the description information and the scheduling control information of the message to the sink task. .

In the flow shown in Figure 2, the message image that constitutes the message queue is separated from the message control block that describes and controls the message. When receiving the message, there is no need to copy the message control block and the data buffer, but only the slave task message image The message image of the message in the queue, according to the message pointed to by the message image The control block feeds back the description information and the scheduling control information of the message to the sink task, so that the message receiving process does not need to perform a repeated data copy operation, so that the message can be received at a high speed without using extra memory, which can save memory overhead and improve the message. The efficiency of reception.

The implementation of the multi-core processor message scheduling method in the embodiment of the present invention is specifically illustrated below. Figure

3 is a schematic diagram of an implementation scenario of a multi-core processor message scheduling method. In FIG. 3, an implementation entity/module involved in a multi-core processor message scheduling method may include the following parts: a message scheduling interface, a three-level scheduling mechanism, and a scheduler.

The message scheduling interface provides a series of function primitives, including: message creation primitive, message sending primitive, message receiving primitive, message release primitive, synchronization message sending primitive, and synchronous response message sending primitive.

The three-level scheduling mechanism is for ease of description, and will involve three parts for the scheduler management and scheduling messages, including: message image queue cluster, message control block set, and data buffer set together called "three-level scheduling mechanism" " .

Among them, the message image queue cluster is divided into two categories: intra-core message image queue cluster, inter-core message image queue cluster.

The message image is the image of the receiving message of the task and the kernel in the corresponding message queue, which points to the message control block that receives the message.

Each task on each core has a message image queue, and the message images it receives from this task are organized in a linked list. In general, all message images enter and exit this queue in FIFO (First In First Out) mode, which is added from the end of the queue and extracted from the head of the team. The message image queue for all tasks of a kernel constitutes the kernel's intra-core message image queue cluster.

In addition to the intra-core message image queue cluster, each core also has an inter-core message image queue. The message images received by all tasks of a kernel from tasks on other cores are first arranged in the inter-core message image queue of the kernel, and the scheduler transfers them one by one to the message image queue of the corresponding receiving task. The inter-core message image queue is also in the form of a linked list, and the message image also enters and exits the queue in FIFO mode. The intercore message image queues of all cores form the intercore message image queue cluster of the multicore processor. Control block. A message control block records description information and scheduling control information of a message. in case The message carries less data. The message control block can contain all the information of the message. If the message needs to carry more data, the data can be stored in a data buffer, pointed to by the buffer pointer in the message control block. This data buffer. Whether the data needs to be stored in a data buffer may be determined according to actual conditions, for example, according to the amount of data that the message can carry.

The data buffer set contains all the data buffers indicated by the message control block because the message carries more data. The size of the data buffer varies depending on the amount of data carried by the corresponding message.

The message classification is explained below in conjunction with the dynamic memory management example in the embodiment of the present invention shown in FIG. 4, and the relationship between the components in the three-level scheduling mechanism shown in FIG. 3 is further explained.

Messages are divided into signal messages and buffer messages depending on whether or not the data buffer is used. In Figure 4, the control block of message B does not carry a data buffer, which is a signal message; the control blocks of messages A, C, and D respectively carry data buffers of different sizes, which are buffer messages.

According to whether the receiving task is unique, the message is divided into a unicast message and a broadcast message. The receiving task is also called the sinking task. Correspondingly, the sending task is also called the source task. A message has only one source task, recorded in the message control block; and there can be multiple sink tasks, which are recorded in its message image. In Figure 4, the control blocks of messages A, B, and C are indicated by multiple message maps, that is, they all have multiple sink tasks, so they are broadcast messages; message D is only indicated by one message map, which is a unicast message.

According to whether the source task and the sink task belong to the same kernel, the message is divided into the intra-core message and the inter-core message. In particular, if a plurality of sink tasks of a broadcast message belong to the same kernel as its source task, and some belong to different cores, then it is both a nuclear message and an inter-core message. For intra-core messages, the scheduler directly adds its message image to the message image queue of the sink task; for inter-core messages, the scheduler first adds its message image to the inter-core message image queue of the kernel to which the sink task belongs, and then Transfer it to the message image queue of the sink task. In Figure 4, the two sink tasks of message C belong to core 1 and core 2, respectively, which are inter-core messages; two message images of message A, one of which is located in the inter-core message image queue of core 2, which is about to be transferred. Go to the message image queue of a task of core 2, and therefore also the inter-core message.

The message is further divided into a normal message, a synchronization message, and a synchronization response message according to whether the transmission process is accompanied by a change in the running state of the task. The normal message is sent in a non-blocking manner, and the scheduler does not change the running status of the source task and the sink task. The synchronization message is sent in blocking mode, and the scheduler is doing it. The source task is placed in a blocking state while the information image is added to the sink task message image queue. In contrast, when the synchronous response message is sent, the scheduler releases the blocking state of the sink task, so that it can continue to run. Different from the general situation, the message image of the synchronous response message is not added to the message image queue of the sink task in FIFO mode, and the scheduler inserts it into the position of the leader of the queue, so that the message is received first after the sink task continues to run.

The three-level message scheduling mechanism, as well as the creation, transmission, reception, and release of various messages, can be managed and scheduled by the scheduler. When the source task creates a message, the scheduler generates a message control block that establishes a connection between the message control block and the data buffer of the source task input. When the source task sends a message, the scheduler generates a message image, which points to the message control block. For the intra-core message, it is added directly to the sink task message image queue. For the inter-core message, before the core of the sink task The relay of the inter-core message image queue. When the sink task receives the message, the scheduler extracts a message image from the message image queue of the current task, and according to the message control block indicated by it, feeds back the message source, the message type and the data buffer carried by the message to the sink task, Release the message image. When the sink task releases the message, the scheduler releases the message control block and the data buffer carried by the message after confirming that the message has no other sink tasks.

As mentioned earlier, for the sending of synchronization messages and synchronization response messages, the scheduler also needs to change the running status of the source task and the sink task accordingly.

In one embodiment, various functional primitives of the message scheduling interface shown in FIG. 3 are described as follows: The message creation primitive accepts the message type, message name, and message body of the source task input. For a signal message, the message body is the message data itself that needs to be sent; for a buffer message, the message body contains a pointer to the data buffer carried by the message, the location of the message data in the buffer, and the length of the message data. The message creation primitive triggers the message creation process of the scheduler, and the execution ends to feed back the message handle to the source task.

The message sending primitive accepts the sink message identifier input by the source task and the message handle to be sent, and triggers the message sending process of the scheduler.

The message receiving primitive triggers the message receiving process of the scheduler, and the execution ends to feed back a message handle of the received message to the sink task, and the message type, source task identifier, message name, and message body of the message. For signal messages, the message body is the message data itself. For buffer messages, the message body includes the data buffer pointer, the location of the message data in the buffer, and the length of the message data. The message release primitive accepts the message handle input by the sink task, triggering the message release process of the scheduler. The synchronization message sending primitive and the synchronization response message sending primitive accept the same input as the message sending primitive, triggering the scheduler's synchronization message sending process and the synchronous reply message sending process.

The three-level scheduling mechanism shown in Figure 3 and Figure 4 is based on the message control block data structure and message image data structure shown in Tables 1 and 2.

Table 1 Message Control Block Data Structure

In a specific implementation, the multi-core processor message scheduling method in the embodiment of the present invention may be composed of the following scheduling processes when sending a message: a message creation process, a message sending process, a synchronous message sending process, and a synchronous response message sending process; , can be composed of the following scheduling process: message receiving process, message release process.

Step 101 in FIG. 1 is a message creation process. The specific implementation may include: filling a message type, a source task identifier, and a message name in the message control block; if the message is a signal message not carrying a data buffer, Filling the message data in the message body of the message control block; or, if the message is a buffer message carrying a data buffer, filling the data buffer pointer and the message data in the message body of the message control block Location and length.

As shown in FIG. 5, in an embodiment, the detailed operation process of the message creation process may include: Step 501: Obtain a message control block from a memory pool;

Step 502, filling the message type, the source task identifier, the message name in the message control block; Step 503, determining the message type, if it is a signal message, executing step 504, if it is a buffer area message, executing step 505;

Step 504, directly filling the message data in the message control block, performing step 506;

Step 505, filling in the data buffer pointer, the location and length of the message data in the message control block, step 506;

Step 506: Feedback the message handle, and end processing.

For a signal message carrying less information, the message data is copied into the message control block for transmission; for a buffer message carrying a large amount of information, the pointer of the data buffer and the message data are directly transmitted through the message control block. The location and length of the punching area. Therefore, no matter whether there are a large number of data copies in the subsequent message sending and receiving processes between the same kernel task or between different kernel tasks, high-speed transfer can be realized.

Steps 102 and 103 in FIG. 1 are message sending processes. In specific implementation, step 102 may include: pointing a message control block pointer of the message image to the message control block; filling the sink task identifier, the synchronization response flag, and the linked list in the message image pointer. Step 103 may include: when the message is an intra-core message, directly adding the message image to a sink task message image queue; or, when the message is an inter-core message, mapping the message to a kernel to which the host task belongs The inter-core message image queue is transferred to the sink task message image queue. In one embodiment, the message sending process is divided into an execution part of the kernel in which the scheduler belongs to the source task and an execution part of the kernel to which the scheduler belongs in the sink task.

As shown in FIG. 6 , in this example, the scheduler is in the execution part of the kernel to which the source task belongs, where the scheduler compares the source task identifier recorded in the message control block with the input sink task identifier, and determines whether the message to be sent is a core message or Inter-core news. Specifically, the comparison is the core number of the task in the source task identifier and the core number of the task in the sink task identifier to determine whether the message is a nuclear message or an inter-core message. For intra-core messages, add the message image directly to the message image queue of the sink task; for inter-core messages, after adding the message image to the inter-core message image queue of the kernel to which the sink task belongs, trigger the inter-core interrupt to the kernel to which the sink task belongs. . The detailed operation flow of the scheduler in the execution part of the kernel to which the source task belongs in the message sending process of FIG. 6 may include:

Step 601: Obtain a message image from a memory pool.

Step 602: Fill the sinking task identifier in the message image, and point it to the message control block. Step 603: Determine whether it is an intra-core message or an inter-core message. If it is an intra-core message, perform step 604. If it is an inter-core message, perform the step. 605;

Step 604: Add a message image queue to the sink task, and end the processing;

Step 605: Add an inter-core message image queue to the kernel to which the sink task belongs;

Step 606: Trigger an inter-core interrupt, and end processing.

Figure 7 shows the execution part of the kernel to which the scheduler belongs in the present example. The scheduler responds to the inter-core interrupt of the kernel to which the sink task belongs, and extracts the message image one by one from the inter-core message image queue of the kernel. The sink task IDs are transferred to the message image queue of the corresponding sink task. The detailed operation flow of the scheduler in the execution part of the kernel to which the scheduler belongs in the message sending process of FIG. 7 may include:

Step 701: Inter-core interruption is generated;

Step 702: Extract a message image from the inter-core message image queue of the kernel. Step 703: Transfer the message image to a message image queue of the sink task.

Step 704: Determine whether the inter-core message image queue of the kernel is empty, and if yes, end the processing, otherwise proceed to step 702 to continue.

In an embodiment, if the message is a synchronization message, after adding the message image to the sink task message image queue, the method may further include: placing the source task in a blocking state, waiting to be received from The source task continues to run after the synchronization response message of the sink task.

The synchronization message sending process is also divided into the execution part of the kernel in which the scheduler belongs to the source task and the execution part of the kernel to which the scheduler belongs in the sink task.

As shown in FIG. 8, in an embodiment, the detailed operation process of the scheduler in the execution part of the kernel to which the source task belongs during the synchronization message sending process may include:

Step 801: Obtain a message image from a memory pool.

Step 802: Fill the sinking task identifier in the message image, and point it to the message control block. Step 803: Determine whether it is an intra-core message or an inter-core message. If it is an intra-core message, perform step 804. If it is an inter-core message, perform the step. 805;

Step 804, adding a message image queue to the sink task, performing step 807;

Step 805: Add an inter-core message image queue to the kernel to which the sink task belongs;

Step 806, triggering an inter-core interrupt, performing step 807;

Step 807: Put the source task into a blocking state, and end the processing.

As shown in FIG. 9, in an embodiment, the detailed operation process of the scheduler in the execution part of the kernel to which the sink task belongs during the synchronization message sending process may include:

Step 901: Inter-core interruption is generated;

Step 902: Extract a message image from the inter-core message image queue of the kernel. Step 903: Transfer the message image to a message image queue of the sink task.

Step 904: Determine whether the inter-core message image queue of the kernel is empty. If yes, the process ends. Otherwise, go to step 902 to continue.

It can be seen from FIG. 8 and FIG. 9 that the synchronization message sending process is different from the normal message sending process in that: the scheduler not only adds the message image of the synchronization message to the message image queue of the sink task of the synchronization message, but also The source task of the synchronization message is placed in a blocking state so that it can continue to run after receiving a synchronization response message from the sink task of the synchronization message.

In one embodiment, if the message is a synchronization response message, the message image is added to the head of the sink task message image queue of the synchronization response message, and the blocking status of the sink task of the synchronization response message is released. .

The synchronization response message transmission process is also divided into an execution part of the kernel to which the scheduler belongs and a execution part of the kernel to which the scheduler belongs in the sink task. As shown in FIG. 10, in an embodiment, the detailed operation procedure of the scheduler in the execution part of the kernel to which the source task belongs during the synchronization response message sending process may include:

Step 1001: Obtain a message image from a memory pool.

Step 1002: pad the sink task identifier in the message image, and point it to the message control block; Step 1003, set a synchronization response flag;

Step 1004: Determine whether it is an intra-core message or an inter-core message. If it is an intra-core message, go to step 1005. If it is an inter-core message, go to step 1007.

Step 1005: Insert a team leader of the queue task message image queue;

Step 1006: Dissolve the blocking state of the sink task, and end the processing;

Step 1007: Add an inter-core message image queue to the kernel to which the sink task belongs;

Step 1008: Trigger an inter-core interrupt and end processing.

As shown in FIG. 11, in an embodiment, the detailed operation procedure of the scheduler in the execution part of the core to which the sink task belongs during the synchronization response message sending process may include:

Step 1101: Inter-core interruption is generated;

Step 1102: Extract a message image from the inter-core message image queue of the kernel; Step 1103: Transfer the message image to a message image queue of the sink task, and insert the message from the head position;

Step 1104: Release the blocking state of the sink task.

Step 1105: Determine whether the inter-core message image queue is empty, and if yes, end the process, otherwise proceed to step 1102 to continue.

It can be seen from FIG. 10 and FIG. 1 that the synchronization reply message sending process is different from the normal message sending process in that:

In the execution part of the kernel to which the source task belongs, the scheduler sets a synchronization response flag in the message image of the message, and after determining that it is a nuclear message, inserts the message image queue of the sink task from the head position, and finally releases the blocking state of the sink task. ;

After judging that it is an inter-core message, in the execution part of the kernel to which the sink task belongs, the scheduler inserts the message into the head of the sink task message image queue according to the synchronization response flag in the message image, and also cancels the blocking state of the sink task.

Steps 201 and 202 in FIG. 2 are message receiving processes. In specific implementation, step 202 may include: Feedback source task identifier, message type, message name; if the message is a signal message that does not carry a data buffer, feedback message data; or, if the message is a buffer message carrying a data buffer, feedback data The buffer pointer, the location and length of the message data. In an embodiment, after step 202, the method further includes: releasing a memory resource of the message image.

As shown in FIG. 12, in an embodiment, the detailed operation process of the message receiving process may include: Step 1201: Extract a message image from a message image queue of the task;

Step 1202: Obtain a message control block.

Step 1203, feedback message handle, source task identifier, message type, message name;

Step 1204, determining the message type, if it is a signal message, executing step 1205, if it is a buffer zone message, executing step 1206;

Step 1205, feedback message data, performing step 1207;

Step 1206, the feedback data buffer pointer, the location and length of the message data, step 1207;

Step 1207: Release the memory resource of the message image, and end the process.

In an embodiment, after the message receiving process, the message release process may further include: if the message is a signal message that does not carry a data buffer, and the message has no other sink task, Release the memory resource of the message control block; or, if the message is a buffer message carrying a data buffer, and the message has no other sink task, release the message control block and the data buffer Memory resources.

As shown in Figure 13, in an embodiment, the detailed operation process of the message release process may include: Step 1301: Determine whether the message has other sink tasks, and if so, end the process, otherwise perform step 1302;

Step 1302, determining the message type, if it is a signal message, performing step 1303, if it is a buffer zone message, executing step 1304;

Step 1303: Release the memory resource of the message control block, and end processing;

Step 1304: Release the memory resource of the message control block and the memory resource of the data buffer carried by the message, and end the process. It can be completed by a program to instruct related hardware, and the program can be stored in a computer. In the reading of the storage medium, the program may include all or part of the steps in the foregoing embodiment, and the storage medium may include: a ROM, a RAM, a magnetic disk, an optical disk, and the like.

A multi-core processor message scheduler is also provided in the embodiment of the present invention, as described in the following embodiments. Since the principle of solving the problem by the multi-core processor message scheduler is similar to that of the multi-core processor message scheduling method, the implementation of the multi-core processor message scheduler can be referred to the implementation of the multi-core processor message scheduling method, and the repetition will not be repeated.

As shown in FIG. 14, the multi-core processor message scheduler in the embodiment of the present invention may include: a first generation module 1401, a message control block for generating a message, the message control block recording description information and scheduling control of the message Information

a second generating module 1402, configured to generate a message image of the message, where the message image points to the message control block;

Add module 1403, which is used to add the message image to the sink task message image queue. In an embodiment, the first generating module 1401 may include:

a first padding unit, configured to fill a message type, a source task identifier, and a message name in the message control block;

a second filling unit, configured to fill message data in a message body of the message control block when the message is a signal message that does not carry a data buffer; or, in the message, a data buffer When the message is buffered, the data buffer pointer, the position and length of the message data are filled in the message body of the message control block. As a device, the second padding unit may include an entity for filling message data in a message body of the message control block when the message is a signal message not carrying a data buffer, and for the message being When a buffer message carrying a data buffer is carried, any one or a combination of the data buffer pointer, the location of the message data, and the length of the entity are filled in the message body of the message control block.

In an embodiment, the second generating module 1402 can include:

a third padding unit, configured to point a message control block pointer of the message image to the message control block;

And a fourth filling unit, configured to populate the sink task identifier, the synchronization response flag, and the linked list pointer in the message image.

In an embodiment, the adding module 1403 can also be used to: When the message is an intra-core message, the message image is directly added to the sink task message image queue; or

When the message is an inter-core message, the message image is transferred to the sink task message image queue via the inter-core message image queue of the kernel to which the sink task belongs.

As an apparatus, the adding module 1403 may include an entity for directly adding the message image to a sink task message image queue when the message is an intra-core message and for when the message is an inter-core message, Any one or a combination of two of the entities in the inter-core message image queue of the kernel to which the message is to be hosted to the task message image queue.

In an embodiment, if the message is a synchronization message, the multi-core processor message scheduler shown in FIG. 14 may further include:

a blocking module, configured to: after the adding module adds the message image of the synchronization message to the sink task message image queue, placing the source task in a blocking state, and continuing to run the source task after receiving the synchronization response message from the sink task .

If the message is a synchronization response message, the adding module 1403 may be further configured to add a message image of the synchronization response message to a head of the sink task message image queue; the multi-core processor message scheduler may further include :

The blocking release module is configured to cancel the blocking state of the sink task after the adding module adds the message image to the head of the sink task message image queue.

As shown in FIG. 15, the multi-core processor message scheduler in the embodiment of the present invention may include: an extracting module 1501, configured to extract a message image of a message from a sink task message image queue; and a feedback module 1502, configured to The message control block pointed to by the message image feeds back the description information and the scheduling control information of the message to the sink task.

In one embodiment, the feedback module 1502 can include:

a first feedback unit, configured to feed back a source task identifier, a message type, and a message name;

a second feedback unit, configured to: when the message is a signal message that does not carry a data buffer, feed back the message data; or, when the message is a buffer message carrying a data buffer, the feedback data buffer The area pointer, the location and length of the message data.

In an embodiment, the multi-core processor message scheduler shown in FIG. 15 may further include: a first release module, configured to release a memory resource of the message image; a second release module, configured to release a memory resource of the message control block when the message is a signal message that does not carry a data buffer, and if there is no other sink task; or, the message is a portable data buffer When the zone's buffer message and there are no other sink tasks, the memory resources of the message control block and the data buffer are released.

In the embodiment of the present invention, the message image constituting the message queue is separated from the message control block for describing and controlling the message. When the message is sent, it is not necessary to copy the message control block and the data buffer, but only the message image and the message are generated. The image is added to the message image queue of the corresponding sink task; when receiving the message, only the message image of the message needs to be extracted from the sink task message image queue, and the description information of the message is fed back to the sink task according to the message control block pointed to by the message image and Scheduling control information; thus, in the messaging process, high-speed transmission of messages can be realized without repeated data copying operations, and no additional memory is needed, which can save memory overhead and improve message transmission efficiency.

The multi-core processor message scheduling method and the scheduler in the embodiment of the invention can implement high-speed message delivery in various scenarios, and greatly reduce the time overhead of the message scheduling function.

1. For a signal message carrying less information, copy the message data into the message control block for transmission; for a buffer message carrying a large amount of information, directly passing the pointer of the data buffer and the message data through the message control block The position and length of the buffer. Therefore, no matter whether there are a large number of data copies in the message sending and receiving process between the same kernel task or between different kernel tasks, high-speed delivery is realized.

Second, the message image that constitutes the message queue and the message control block that describes and controls the message are separated. In the case of message broadcast, only multiple message images are added to the message image queue of the corresponding sink task without copying the message control. Block and data buffers for high-speed message broadcast.

Third, in the case of message forwarding, it is only necessary to regenerate the message image of the received message, and it is not necessary to copy the message control block and the data buffer, thereby time-high-speed message forwarding.

In the above various scenarios, the multi-core processor message scheduling method and the scheduler of the embodiment of the present invention directly transmit a buffer that carries message data for a case where there is a large amount of information, and transmits a message control block for a case where the amount of information is small. Message data, no extra memory is used. Therefore, the memory overhead of the message scheduling function can also be greatly reduced.

The multi-core processor message scheduling method and the scheduler of the embodiment of the present invention can support variable length messages and variable length message queues without setting the maximum amount of data carried by the message and the length limit of the message queue. The embodiments of the present invention are particularly applicable to multi-core DSP software with limited on-chip memory capacity and extremely high real-time requirements.

The above described specific embodiments of the present invention are further described in detail, and are intended to be illustrative of the embodiments of the present invention. The scope of the protection, any modifications, equivalent substitutions, improvements, etc., which are within the scope of the invention, are intended to be included within the scope of the invention.

Claims

Claim

A multi-core processor message scheduling method, the method comprising: generating a message control block of a message, wherein the message control block records description information and scheduling control information of the message;

2. The method according to claim 1, wherein the message control block records the description information and the scheduling control information of the message, including:

The message control block is populated with a message type, a source task identifier, and a message name;

If the message is a signal message that does not carry a data buffer, the message body of the message control block is filled with message data, or

If the message is a buffer message carrying a data buffer, the message body of the message control block is filled with a data buffer pointer and the position and length of the message data.

The method of claim 1 or 2, wherein the message image points to the message control block, comprising:

The message control block pointer of the message map points to the message control block.

The method according to any one of claims 1 to 3, characterized in that the generated message image of the message is filled with a sink task identifier, a synchronization response flag and a linked list pointer.

The method according to any one of claims 1 to 4, wherein the adding the message image to the sink task message image queue corresponding to the message comprises:

When the message is a nuclear message, the message image is directly added to the queue message message image queue; or

6. A method according to any one of claims 1 to 5, characterized in that

If the message is a synchronization message, after the message image is added to the sink task message image queue corresponding to the synchronization message, the method further includes: placing the source task corresponding to the synchronization message in a blocking state, to be received The source task is resumed after the synchronization response message from the sink task corresponding to the synchronization message; or If the message is a synchronization response message, the message image is added to the head of the sink task message image queue corresponding to the synchronization response message, and the blocking state of the sink task corresponding to the synchronization response message is released.

The method according to any one of claims 1 to 6, wherein the method further comprises: extracting a message image of the message from a sink task message image queue corresponding to the message; The message control block pointed to by the image feeds back the description information and the scheduling control information of the message to the sink task.

The method according to claim 7, wherein the message description information and the scheduling control information are fed back to the sink task according to the message control block pointed to by the message image, including:

Feedback source task ID, message type, and message name;

If the message is a signal message that does not carry a data buffer, feedback message data, or if the message is a buffer message carrying a data buffer, feedback data buffer pointer, and location and location of the message data length.

A multi-core processor message scheduling method, the method comprising: extracting a message image of a message from a sink task message image queue;

And according to the message control block pointed to by the message image, the description information of the message and the scheduling control information are fed back to the sink task.

The method according to claim 9, wherein the message description information and the scheduling control information are fed back to the sink task according to the message control block pointed to by the message image, including:

Feedback source task ID, message type, and message name;

The method according to claim 9 or 10, further comprising:

Freeing the memory resources of the message image;

If the message is a signal message that does not carry a data buffer, and the message has no other sink tasks, the memory resource of the message control block is released, or

If the message is a buffer message carrying a data buffer, and the message has no other sink tasks, the memory resources of the message control block and the data buffer are released.

12. A multi-core processor message scheduler, comprising:

The multi-core processor message scheduler according to claim 12, wherein the first generation module comprises:

a first padding unit, configured to fill in a message type, a source task identifier, and a message name in the message control block;

a second filling unit, configured to fill message data in a message body of the message control block when the message is a signal message that does not carry a data buffer, or to buffer the message in the message When the buffer message of the area is filled, the data buffer pointer and the position and length of the message data are filled in the message body of the message control block.

The multi-core processor message scheduler according to claim 12 or 13, wherein the second generation module comprises:

And a fourth filling unit, configured to populate the sinking task identifier, the synchronization response flag, and the linked list pointer in the message image.

The multi-core processor message scheduler according to any one of claims 12 to 14, wherein the adding module is further configured to:

When the message is an intra-core message, the message image is directly added to the sink task message image queue corresponding to the message; or

When the message is an inter-core message, the message image is transferred to the inter-core message image queue corresponding to the message by the inter-core message image queue of the kernel to which the sink task belongs.

16. The multi-core processor message scheduler according to any one of claims 12 to 15, wherein: If the message is a synchronization message, the multi-core processor message scheduler further includes: a blocking module, configured to: after the adding module adds the message image to a sink task message image queue corresponding to the synchronization message, Putting the source task corresponding to the synchronization message into a blocking state, or

If the message is a synchronization response message, the adding module is further configured to add the message image to a head of a sink task message image queue corresponding to the synchronization response message, where the multi-core processor message scheduler further includes :

The blocking release module is configured to release the blocking state of the sink task corresponding to the synchronization response message after the adding module adds the message image to the queue head of the sink task message image queue corresponding to the synchronization response message.

The multi-core processor message scheduler according to any one of claims 12 to 16, further comprising

An extracting module, configured to extract a message image of the message from the sink task message image queue; a feedback module, configured to feed back, according to the message control block pointed by the message image, the description information and the scheduling control information of the message to the sink task .

The multi-core processor message scheduler according to claim 17, wherein the feedback module comprises:

a second feedback unit, configured to: when the message is a signal message that does not carry a data buffer, feed back the message data, or when the message is a buffer message carrying a data buffer, the feedback data buffer The area pointer, as well as the location and length of the message data.

19. A multi-core processor message scheduler, comprising:

The multi-core processor message scheduler according to claim 19, wherein the feedback module comprises:

a first feedback unit, configured to feed back a source task identifier, a message type, and a message name; a second feedback unit, configured to: when the message is a signal message that does not carry a data buffer, feed back the message data, or when the message is a buffer message carrying a data buffer, the feedback data buffer The area pointer, as well as the location and length of the message data.

The multi-core processor message scheduler according to claim 19 or 20, further comprising:

a first release module, configured to release a memory resource of the message image;

a second release module, configured to release a memory resource of the message control block when the message is a signal message that does not carry a data buffer, and if there is no other sink task, or When the zone's buffer message and there are no other sink tasks, the memory resources of the message control block and the data buffer are released.