Task processing method and device and storage medium

Abstract

The invention provides a task processing method and device and a non-transitory computer readable storage medium. The task processing method comprises the steps of blocking execution of a first task in response to the fact that the first task queue has the first task; in response to the fact that the at least one second task queue is bound to the first task queue, determining a release-trigger condition for execution blocking of the first task, the release-trigger condition being based on execution information of tasks in the at least one second task queue; in response to determining that the release-trigger condition is satisfied, the execution congestion of the first task is released and the execution of the first task is triggered. According to the task processing method, the time delay of task processing can be reduced, and the task throughput and the task processing efficiency of the system are improved.

Description

Technical Field

[0001] Embodiments of the present disclosure relate to a task processing method and apparatus, and a non-transitory computer-readable storage medium. Background Art

[0002] Remote Direct Memory Access (RDMA) is used to address the latency in task processing between two computing nodes in network data transmission. It transfers data directly from the memory of one computing node to the memory of another computing node without the intervention of the operating systems of both parties. Summary of the Invention

[0003] According to one aspect of the present disclosure, at least one embodiment provides a task processing method, which includes: blocking the execution of a first task in response to the first task queue having the first task; determining a release-trigger condition for the blocking of the execution of the first task in response to at least one second task queue being bound to the first task queue, where the release-trigger condition is based on the execution information of the tasks in the at least one second task queue; and releasing the blocking of the execution of the first task and triggering the execution of the first task in response to determining that the release-trigger condition is satisfied.

[0004] According to another aspect of the present disclosure, at least one embodiment provides a task processing apparatus, which includes: a blocking unit configured to block the execution of a first task in response to the first task queue having the first task; a determining unit configured to determine a release-trigger condition for the blocking of the execution of the first task in response to at least one second task queue being bound to the first task queue, where the release-trigger condition is based on the execution information of the tasks in the at least one second task queue; and a triggering unit configured to release the blocking of the execution of the first task and trigger the execution of the first task in response to determining that the release-trigger condition is satisfied.

[0005] According to another aspect of the present disclosure, at least one embodiment provides a task processing apparatus, including: a storage device storing computer instructions; and a processing device configured to execute the computer instructions in the storage device to execute the task processing method according to at least one embodiment of the present disclosure.

[0006] According to another aspect of the present disclosure, at least one embodiment provides a non-transitory computer-readable storage medium having computer instructions stored thereon, where the computer instructions, when executed by a processor, cause the processor to execute the task processing method according to at least one embodiment of the present disclosure.

[0007] Thus, by blocking the execution of the first task in response to the first task queue having the first task, the processor or other hardware of, for example, a computing node can be made to pause processing or polling the first task queue. By determining, in response to at least one second task queue being bound to the first task queue, a de-trigger condition for the blocking of the execution of the first task based on the execution information of the tasks in the at least one second task queue, it is thus determined that the triggering of the execution of the tasks in the first task queue is related to the execution of the tasks in the at least one second task queue. Until it is determined that the de-trigger condition is satisfied, the blocking of the execution of the first task is lifted and the execution of the first task is triggered. Thus, the triggering and execution of the first task can be automatically completed while reducing or eliminating the load on the hardware, thereby reducing the latency of task processing, increasing the throughput, and improving the task processing efficiency.

[0008] This section is provided in a brief form to introduce the embodiments of the present disclosure, which will be described in detail in the following detailed description section. This section is not intended to identify the key features or essential features of the claimed technical solution, nor is it intended to limit the scope of the claimed technical solution. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In conjunction with the accompanying drawings and with reference to the following detailed description, the above and other features, advantages, and aspects of the embodiments of the present disclosure will become more apparent. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic and the original and elements are not necessarily drawn to scale.

[0010] Figure 1 An example system operation diagram showing data transmission between multiple computing nodes is shown.

[0011] Figure 2 A scenario diagram showing a task processing scheme according to at least one embodiment of the present disclosure is shown.

[0012] Figure 3 A flowchart showing a task processing method according to at least one embodiment of the present disclosure is shown.

[0013] Figure 4 A schematic diagram showing a task processing method according to at least one embodiment of the present disclosure is shown.

[0014] Figure 5 A block diagram showing a task processing apparatus according to at least one embodiment of the present disclosure is shown.

[0015] Figure 6 A block diagram showing an electronic device according to at least one embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0016] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although some embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Instead, these embodiments are provided to more thoroughly and completely understand the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes and are not used to limit the protection scope of the present disclosure.

[0017] It should be understood that the various steps recited in the method embodiments of the present disclosure can be executed in a different order and / or in parallel. In addition, the method embodiments may include additional steps and / or omit the steps shown. The scope of the present disclosure is not limited in this regard.

[0018] As used herein, the term "including" and its variations are open-ended, that is, "including but not limited to". The term "based on" is "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". The relevant definitions of other terms will be given in the following description.

[0019] It should be noted that the concepts such as "first", "second", etc. mentioned in the present disclosure are only used to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependent relationships.

[0020] It should be noted that the modifications of "one" and "plural" mentioned in the present disclosure are illustrative rather than restrictive. Those skilled in the art should understand that unless otherwise clearly stated in the context, it should be understood as "one or more".

[0021] Note that in this document, "in response to A, perform B" can mean "perform B in the case of A", "perform B when A occurs", etc., and does not limit that B is performed immediately after A occurs, nor does it limit the occurrence time and order of A and B.

[0022] The names of the messages or information exchanged between multiple devices in the embodiments of the present disclosure are only for illustrative purposes and are not used to limit the scope of these messages or information.

[0023] In distributed computing, data transmission usually occurs between multiple computing nodes. A large number of processors of computing nodes are required to participate in operations such as preparation and polling before sending data. Due to the deep participation of the processors, this communication process results in increased latency and limited throughput.

[0024] Figure 1 A system operation diagram for data transmission between multiple computing nodes is shown.

[0025] As shown Figure 1 in the figure, multiple computing nodes that are communicatively connected to each other are shown, including computing node 110, computing node 120, computing node 130, etc. Computing node 110 includes a processor (such as a CPU as an example in Figure 1 ) 111, a memory 112, a network interface device 113, etc. Similarly, computing node 120 includes a CPU 121, a memory 122, and a network interface device 123. Computing node 130 includes a CPU 131, a memory (not shown), and a network interface device 132. The network interface device can also be managed by a driver, which can be a type of system software running on the processor of the current computing node or a program running on a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), or an intelligent chip, etc. of the network interface device. The present disclosure does not limit this.

[0026] The processor in the present disclosure includes units responsible for executing instructions stored in the memory and processing various data operations and logical operations, and is not limited to the types exemplified herein. Although a CPU is shown as an example in the figure, other processors such as GPUs are also included in one or more embodiments of the present disclosure; the processor can be a processor adopting various applicable architectures or instruction sets, such as x86, Advanced Reduced InstructionSet Computer Machines (ARM), Reduced Instruction Set Computer-V (RISC-V), Million Instructions Per Second (MIPS), etc.

[0027] A network interface device or network adapter (also known as a Network Interface Card or NIC) can be used to enable communication between multiple computing nodes, including sending and receiving data. For example, the network interface device is responsible for converting the data inside the computing node into a transmissible format, and receiving data from other computing nodes and converting it into a format that the computing node can understand. The network interface device can support multiple network protocols (such as Transmission Control Protocol / Internet Protocol (TCP / IP), User Data Protocol (UDP), etc.) to communicate with the network interface devices of other computing nodes. The network interface device is implemented in hardware, and the implementation method can be implemented by using at least one of an Application Specific Integrated Circuit (ASIC), a Digital Signal Processor (DSP), a Digital Signal Processing Device (DSPD), a Programmable Logic Device (PLD), a Field Programmable Gate Array (FPGA), a processor, a controller, a microcontroller, a microprocessor, or other electronic units designed to perform the functions described herein.

[0028] The network interface device 123 (and its driver) can maintain a receive queue, a transmit queue, a completion queue, etc. Here, the queue can provide a set of tasks; the set of tasks can include various forms of structures for accommodating tasks, such as including but not limited to resource blocks, stacks, tables, databases, and so on. The network interface device 123 can include input / output ports.

[0029] During operation, for example, when computing node 110 needs to first write data to computing node 120, after computing node 120 confirms receiving the data, it then writes data to computing node 130. Note that for the sake of illustration and brevity, the modules and operations in computing node 120 are mainly shown and described in detail below, and the modules and operations in computing node 110 and computing node 130 are omitted. The operation modes of other computing nodes can be obtained by referring to the operation description of computing node 120.

[0030] Throughout the process, before data is sent, in step 1, the CPU 121 of computing node 120 performs receive preparation and pre-submits (post_recv) receive WQEs to the receive queue QPx.

[0031] Here, the WQE can be regarded as a task. Of course, this task can also be represented in other forms, such as using one or more instructions, commands, operations, business processes, etc. The task contains the specific task content to be executed (such as sending, receiving, writing, reading, etc.) and its possible detailed information, such as the address where the data to be transmitted is located, the destination address of the data transmission, the length of the data, or the secret key, etc.

[0032] In the RDMA field, tasks can include various RDMA primitives, such as sending (SEND), receiving (RECV), writing (WRITE), reading (READ), atomic operations (ATOMIC) (for example, Compare And Swap (CAS) and Fetch And Add (FAA)), and Write with Immediate (Imm).

[0033] Figure 1 The Write with Immediate (WRITE_WITH_IMM) primitive exemplified in allows a computing node (sender) to not only write data into the memory of another computing node (receiver), but also send an immediate data to the receiver at the same time. This immediate data can be used to carry some additional information or signals, such as an acknowledgement message, an operation code, etc. This immediate data will not be written into the target address of the remote memory, but will be notified to the application or client at the receiving end through the Completion Queue (CQ) after the RDMA operation is completed.

[0034] In step 2, after the reception preparation is completed, the CPU 121 writes a flag bit to the memory 112 of the computing node 110, indicating the memory address where the data received by the computing node 120 is to be stored.

[0035] In step 3, the CPU 111 of the computing node 110 polls its memory 112 and determines the flag bit, and learns the memory address where the data it sends to the computing node 120 is to be stored.

[0036] In step 4, the network interface device 113 writes the data into the corresponding memory address in the memory 122 of the computing node 120.

[0037] In step 5, the CPU 121 continuously polls the Completion Queue to determine whether the data has been stored in the corresponding memory address in the memory 122. Here, when the WQE in the receive queue (referred to as the receive WQE here) is completed (i.e., the data is stored in the corresponding memory address in the memory 122), the network interface device 123 of the compute node 120 adds a Completion Queue Element (CQE) to the Completion Queue, so that the CPU 121 can obtain the CQE during the polling process and confirm that the data has been stored in the corresponding memory address in the memory 122.

[0038] In step 6, when the CPU 121 is ready to send data to the compute node 130, the CPU 131 in the compute node 130 prepares to receive and writes a flag bit to the computer memory 122 to indicate the memory address where the data received by the compute node 130 is to be stored.

[0039] In step 7, the CPU 121 polls the memory 122 to obtain the flag bit and learns the memory address where the data it sends to the compute node 130 is to be stored.

[0040] In step 8, the CPU 121 pre-submits (post_send) the send WQE to the send queue QPy, and then the network interface device 123 executes the send WQE to send the data to the network interface device 132.

[0041] And so on, the subsequent operation process of the compute node 130 is similar to the corresponding operation process of the compute node 120, which will not be elaborated here.

[0042] In the above process, the processors of each computing node need to continuously poll whether the previous WQE is completed (by polling the CQE generated by the WQE) to start executing the subsequent WQE, which occupies the processor resources. That is, the above process requires the full participation of the CPUs of each computing node, including the preparations before sending (including the negotiation of the memory address for the write operation, the negotiation of the submission of the received WQE, and the construction and submission of the WQE) and the CQE polling and other operations after sending. Due to the deep participation of the CPU, it will lead to an increase in the latency of the communication process and limited throughput. Moreover, the entire process is only applicable to RDMA primitives that can generate CQEs, such as the WQE of Write with IMM. However, for primitives that do not generate CQEs, such as the WQE of RDMA Write, the subsequent triggering cannot be normally achieved. When using primitives such as RDMA Write with Immediate and Send, the processor of the sending party must also submit the received WQE in advance, otherwise the reception will fail. Moreover, it is necessary to bind the QPs where multiple previous WQEs are located to a specific completion queue CQ, so as to monitor the CQEs in the CQ queue to determine whether multiple previous WQEs are executed and completed to trigger the execution of the next WQE. The processor needs to clear the CQEs in the CQ queue (that is, continuously poll the CQ and process the CQEs), otherwise an exception will occur due to the overflow of the CQ queue.

[0043] The defect problems existing in the above solutions are obtained through careful research through practice and creative labor. The discovery process of the above problems and the solutions proposed by at least one embodiment disclosed below for the above problems both belong to creative contributions.

[0044] According to at least one embodiment of the present disclosure, a task processing method is implemented, which solves one or more of the above problems. The task processing method includes: in response to a first task queue having a first task, blocking the execution of the first task; in response to at least one second task queue being bound to the first task queue, determining a release-trigger condition for the blocking of the execution of the first task, where the release-trigger condition is based on the execution information of the tasks in the at least one second task queue; in response to determining that the release-trigger condition is satisfied, releasing the blocking of the execution of the first task and triggering the execution of the first task. The task processing method can automatically complete the blocking and triggering execution of the first task, reduce or eliminate the load such as polling of the first task by the hardware, thereby reducing the latency of task processing and improving the throughput and task processing efficiency.

[0045] In at least one embodiment of the present disclosure, the above task processing method can be used in various applicable scenarios, including but not limited to tasks such as transmitting and receiving data between multiple computing nodes.

[0046] Figure 2A scenario diagram of a task processing solution according to at least one embodiment of the present disclosure is shown.

[0047] Figure 2 The illustrated embodiment includes a plurality of computing nodes communicatively connected to each other, including computing node 210, computing node 220, computing node 230, etc. Computing node 220 includes a processor (such as a CPU as exemplified in Figure 1 ) 221, a memory, a network interface device 222, etc. Similarly, computing node 210 and computing node 230 also respectively include a CPU, a memory, a network interface device (i.e., network interface devices 211 and 231 in the figure), etc.

[0048] In the scenario of data transmission between multiple computing nodes, it is assumed that the current computing node 220 needs to send data to computing node 230 only after receiving data sent by computing node 210. If following the Figure 1 illustrated process, the current node 220 needs to pre-submit a receive WQE to the receive queue, and then poll whether the receive WQE has been executed. When the receive WQE is completed, it will generate a Complete Queue Element (CQE). The current node polls for this CQE and then submits a send WQE to the send queue to send data to computing node 230.

[0049] Figure 3 A flowchart of a task processing method according to at least one embodiment of the present disclosure is shown.

[0050] As Figure 3 shown, the task processing method may include steps 310, 320, and 330. The task processing method may be executed by a network interface device of a host (such as a computing node).

[0051] Step 310, in response to a first task queue having a first task, blocking the execution of the first task.

[0052] Step 320, in response to at least one second task queue being bound to the first task queue, determining a release-trigger condition for the blocking of the execution of the first task. The release-trigger condition is based on the execution information of the tasks in at least one second task queue.

[0053] Step 330, in response to determining that the release-trigger condition is satisfied, releasing the blocking of the execution of the first task and triggering the execution of the first task.

[0054] In this way, the blocking and triggering of the execution of the first task can be automatically completed, reducing or eliminating the load such as polling of the first task by hardware, thereby reducing the task processing delay, improving the throughput, and enhancing the task processing efficiency.

[0055] The following is combined with that inFigure 2 the illustrated embodiment will be described for Figure 3 the illustrated task processing method. As Figure 2 shown, in step 1, the processor 221 of the current node 220 makes preparations before sending to the computing node 230, that is, receives the memory address notification of the computing node 230 and pre-submits the first task in the first task queue (such as the send queue). Here, the task can be implemented in the form of a WQE of an RDMA primitive, and is not limited to the WQE of those primitives that can generate a CQE. For example, the first task can be a send WQE (that is, a "write" (WRITE) WQE for writing data to this memory address). Of course, the embodiments of the present disclosure are not limited thereto.

[0056] In step 2, the network interface device 222 blocks the execution of the first task (write WQE) in response to the first task (write WQE) being present in the send queue. One or more second task queues are bound to the first task queue, and a release-trigger condition for blocking the execution of the first task is set. Here, the release-trigger condition is based on the execution information of the tasks in at least one of the second task queues.

[0057] In step 3, the network interface device 222 completes the data transfer with other computing nodes and determines the execution status of one or more second tasks (such as receive WQEs from the second computing node 210 and / or one or more receive WQEs from one or more other computing nodes, etc.) in the second task queue (such as the receive queue), and thus can determine that the release-trigger condition is satisfied.

[0058] In step 4, in response to the release-trigger condition being satisfied, the network interface device 222 triggers the execution of the first task (that is, the write WQE for writing data to the third computing node 230), so that the network interface device 222 writes data to the third computing node 230.

[0059] In this way, by blocking the execution of the first task in response to the first task queue having the first task, it is possible to cause, for example, the processor or other hardware of the computing node to pause processing or poll the first task queue. By determining the release-trigger condition based on the execution information of the tasks in at least one second task queue in response to at least one second task queue being bound to the first task queue, it is thus determined that the execution of the task in the first task queue is related to the execution status of the tasks in at least one second task queue. Until it is determined that the release-trigger condition is satisfied, the blocking of the execution of the first task is released and the execution of the first task is triggered.

[0060] According to the task processing method of the above-mentioned embodiment of the present disclosure, the data sending preparation stage of the processor is separated out, and when the data is actually sent, the network interface device can automatically trigger the execution of the first task based on the release-trigger condition, thereby avoiding the control and participation of the processor throughout the process, thereby improving execution efficiency and reducing latency.

[0061] The first task queue may include tasks from the current node (e.g. Figure 2 The computing node 220 in the first node (eg, Figure 2 The computing node 230 in the sending queue sends one or more sending tasks of the object data, wherein the one or more sending tasks include a first task, and the first task may be a sending task in a sending queue. Figure 2 In the example, the first task queue may be a sending queue including a plurality of sending tasks. At least one of the at least one second task queues may include the current node from the second node (e.g., Figure 2 The computing node 210 in the embodiment receives one or more receiving tasks of the object data. Figure 2 In the example, the second task queue may be a receiving queue including multiple receiving tasks. In another embodiment, the first task queue may include one or more receiving tasks for the current node to receive object data from the first node, and the one or more receiving tasks may include the first task, that is, the first task queue may be a receiving queue including multiple receiving tasks, and at least one of the at least one second task queues includes one or more sending tasks for the current node to send object data to the third node, that is, the second task queue may be a sending queue including multiple sending tasks.

[0062] Here, any one of the first node, the second node, and the third node may be a node different from the current node, or may be the same node as the current node. In the case where one of the first node, the second node, or the third node is the same node as the current node, the sending task and the receiving task may be a sending task and / or receiving task within the current node.

[0063] In the description of this article, a scenario in which the current node receives data from the second node and then triggers the execution of a sending task to send data to the first node by the completion of the receiving task (the completion of the receiving task triggers the sending task) is taken as an example to describe the implementation process and implementation effect. However, the present disclosure is not limited to this scenario. The completion of the receiving task can also trigger another receiving task, the completion of the sending task can trigger another sending task, the completion of the sending task can trigger the receiving task, and so on. There is no restriction on whether these tasks occur between nodes or within nodes. They are not described one by one here. Those skilled in the art can deduce the implementation process and implementation effects under these scenarios based on the contents of the present disclosure.

[0064] So,Figure 2 For example, before sending data to the first node, the sending task can be automatically blocked so that after the release-trigger condition is met, the blocking of the sending task is released and the current node is triggered to send data to the first node, while reducing or eliminating the load such as polling of the sending task by the hardware.

[0065] For example, in some embodiments, in step 310, blocking the execution of the first task includes: blocking the execution of the first task based on the blocking task corresponding to the first task in the first task queue. In some embodiments, the blocking task can be a blocking WQE for blocking the execution of the sending task. The task content or form of the blocking WQE can be agreed upon by the developer. For example, it can be agreed that a certain field in the specific task content in the WQE is set to a specific value so that when the network interface device processes the blocking WQE, it can understand that the execution of the subsequent sending task of the blocking WQE is to be paused. The specific implementation is not limited thereto. For example, the blocking WQE can be implemented in the form of a chained WQE primitive and has at least one parameter to indicate the condition for releasing the block.

[0066] For example, in some embodiments, blocking the execution of the first task further includes: marking the first task queue as the first state and pausing to respond to the first task queue. For example, the first state can include a suspended state, which can be represented by an identifier of one bit. For example, when the network interface device determines that the identifier of the first task queue is in the suspended state, it no longer responds to any tasks in the first task queue. Therefore, it does not need to poll and process the tasks in the first task queue. In this way, the network interface device can poll the tasks in other task queues that may need to be executed and execute those tasks that need to be executed, thereby reducing the waste of resources of the network interface device.

[0067] For example, in some embodiments, pausing to respond to the first task queue can include: pausing to respond to the knocking operation of the first task queue.

[0068] In the present disclosure, the "knocking operation" means that when the network interface device receives a new data packet that needs to be processed, or has completed certain operations and needs to notify the host, it writes a specific value or command word to the doorbell register. This value or command word usually contains detailed information about the new task or event, such as the queue identifier, task type, etc. For example, the network interface device regularly checks the register value of the doorbell register. Once it finds that the register value of the doorbell register represents the identifier of the first task queue, it will respond to the register value to process the tasks in the first task queue.

[0069] For example, in some embodiments according to the present disclosure, for example, the register value of the first task queue in the response doorbell register can be suspended, thereby suspending the knocking operation of the first task queue. Therefore, the network interface device is to be suspended from responding to the knocking operation of the first task queue, for example, by suspending the register value of the first task queue in the response doorbell register, so as to respond to the register values ​​of other task queues that may need to be executed, to execute those tasks, thereby reducing the resource waste of the network interface device in polling blocked tasks.

[0070] For example, in some embodiments, a user may use an application programming interface (API) to bind at least one second task queue to the first task queue. In some embodiments, the task processing method 300 may further include: in response to at least one second task queue being bound to the first task queue, storing an association relationship between the first task queue and at least one second task queue.

[0071] For example, in some embodiments, the network interface device can use a mapping table to store the association relationship between the first task queue and at least one second task queue. For example, a row of the mapping table records the first task queue and at least one second task queue that is bound, and another row of the mapping table records the third task queue and at least one fourth task queue that is bound... indicating that the task queues recorded in each row are bound. For example, the mapping table is implemented, for example, by a static random access memory device (Static Random-Access Memory, SRAM) and the like. The foregoing is only an example and not a limitation, and the association relationship can also be embodied in other ways.

[0072] In this way, the network interface device can understand which task queue(s) is the active task queue used to trigger the passive task, so that the network interface device can monitor the execution information of the tasks in this(s) active task queue(s) to determine whether the unblocking-triggering condition for the execution of the first task is met and thereby trigger the execution of the passive task.

[0073] For example, in some embodiments, determining the de - trigger condition for the blocking of the execution of the first task may include: determining the de - trigger condition parameter trigger_count of the first task. For example, the de - trigger condition parameter trigger_count may be based on the execution information of the tasks in at least one second task queue. The parameter trigger_count may indicate how many second tasks in total in at least one second task queue are expected to complete their execution to trigger the execution of the first task, that is, after the execution of which second task starting from the first second task in at least one second task queue should trigger the execution of the first task. For example, trigger_count = 7 means that after the execution of the 7th second task starting from the execution of the first second task in at least one second task queue, the execution of the first task should be triggered.

[0074] In some embodiments, the de - trigger condition parameter trigger_count may be set or calculated by the driver of the network interface device. The user can add the parameter trigger_count to the blocking task through the processor. For example, it can be agreed that a field of the blocking WQE can indicate the parameter trigger_count. The driver of the network interface device can know the parameter trigger_count when processing the blocking WQE.

[0075] In some embodiments, determining the de - trigger condition for the blocking of the execution of the first task may also include: determining the de - trigger condition parameter trigger_count of the first task based on the trigger condition parameter chaining_count.

[0076] Each task in the first queue itself may have one or more attributes or parameters. For example, there is a trigger condition parameter chaining_count, which will be used to set the release-trigger condition parameter trigger_count corresponding to this task in the system. The parameter chaining_count for the first task can be used to indicate how many second tasks are expected to be executed and completed before triggering the execution of the first task since the most recent other task in the first task queue was triggered for execution (assuming there are other tasks in the first task queue besides the first task). For example, the parameter chaining_count = 3 means that since the most recent other task in the first task queue was triggered for execution, the execution of the first task will be triggered after 3 second tasks in the second task queue are executed and completed. And this most recent other task may be expected to be triggered after 4 second tasks in at least one second task queue are executed and completed. In this case, the calculated parameter trigger_count for the first task is 7 (3 + 4 = 7), that is, the execution of the first task should be triggered after the 7th second task starting from the execution of the 1st second task in at least one second task queue is executed and completed.

[0077] In some embodiments, the release-trigger condition parameter chaining_count can be set or calculated by a processor. This parameter chaining_count can be added to the blocking task by a user through the processor. For example, a field of the blocking WQE can be agreed to indicate this parameter chaining_count. Sometimes, the user does not know how many second tasks need to be executed and completed in total before the first task. The user only knows how many second tasks need to be executed and completed since the most recent other task was triggered for execution to trigger the execution of the first task. Then, by simply setting the parameter chaining_count, the user's calculation burden can be reduced.

[0078] The above example uses the release-trigger condition parameter trigger_count as the release-trigger condition for the sending task, but this is not a limitation. Other conditions (parameters) can also be used as the release-trigger condition for the sending task, such as timing, etc., and will not be listed one by one here.

[0079] For step 330, for example, in some embodiments, determining that the release-trigger condition is met includes: determining the execution information of the second tasks in at least one second task queue; and based on the execution information, determining whether the release-trigger condition is met.

[0080] For example, the execution information may indicate the completion status of the second task. For example, if the second task is the task for the current node to receive data from the second node, the execution information may indicate whether the data has been transferred from the memory address of the second node to the memory address of the current node.

[0081] The network interface device may maintain an execution information parameter completion_counter for the second task queue. The parameter completion_counter may indicate how many second tasks in at least one second task queue have been actually executed and completed. The parameter completion_counter may be initialized to 0 before at least one second task queue is bound to the first task object and the second task starts to be executed. If each time a second task is actually executed and completed, the parameter completion_counter is incremented by one. Since the network interface device is responsible for data reception and transmission with external nodes, the network interface device knows whether the specific reception task and transmission task have been completed and maintains the parameter completion_counter.

[0082] For example, in some embodiments, at least one of the first task and one or more second tasks may include an RDMA primitive that does not generate a CQE, and the network interface device can also determine the execution information indicating how many second tasks in the second task queue have been actually executed and completed. Therefore, there is no need for the processor to poll the CQEs of the second tasks to determine whether the second tasks are executed and completed, thereby improving the task processing efficiency and expanding the applicable scope.

[0083] For example, in some embodiments, determining whether the release-trigger condition is satisfied based on the execution information may include: in response to the number of second tasks whose execution is indicated as completed by the execution information (i.e., the execution information parameter, completion_counter) being greater than or equal to the release-trigger condition parameter trigger_count, determining that the release-trigger condition is satisfied. This means that the number of second tasks that have actually completed execution has been greater than or equal to the number of tasks that should trigger the execution of the first task, and then the execution of the first task is triggered.

[0084] For example, in some embodiments, releasing the execution block of the first task and triggering the execution of the first task may include: processing the blocking task corresponding to the first task to resume the execution of the first task.

[0085] For example, in some embodiments, unblocking the execution of the first task and triggering the execution of the first task may further include: marking the first task queue as the second state, and resuming to respond to the first task queue to process the blocked tasks corresponding to the first task. For example, the second state is the normal state, and the normal state can be represented by an identifier of one bit. For example, when the network interface device determines that the identifier of the first task queue is the execution state, it responds to and processes the tasks in the first task queue, including the blocked tasks and the first tasks subsequent to the blocked tasks, etc. Specifically, the network interface device may start to respond to the register value in the doorbell register regarding the first task queue.

[0086] In this way, in the case where the unblocking-triggering conditions for each task in the first task queue are determined, the network interface device can understand the triggering conditions of each task in the first task queue. In the actual execution process, the network interface device can automatically count the actually executed second tasks according to the execution information of at least one second task queue, so as to automatically trigger the execution of the corresponding tasks in the first task queue when the execution situation of the second tasks meets the unblocking-triggering conditions. This will enable the serial execution of each task, and the execution efficiency can be greatly improved.

[0087] Figure 4 The figure shows a schematic diagram of a task processing method according to at least one embodiment of the present disclosure.

[0088] Figure 4 The illustrated embodiment corresponds to the current computing node (e.g., Figure 2 the computing node 220 therein), the first task queue may be a send queue (sending data from the current node to other nodes), or may be referred to as a passive queue for this task processing method. Here, the passive queue may refer to the queue where the tasks to be triggered for execution are located. The first task may be a write WQE (WRITE) that does not generate CQE, and the blocked task may be a blocked WQE, which can be constructed to be dedicated to blocking. The second task queue may be a receive queue (receiving data from other computing nodes), or may be referred to as an active queue for this task processing method. Here, the active queue may refer to the queue where at least one second task that triggers the execution of the first task is located. At least one second task queue may include multiple second task queues (such as Figure 4 the queue 1 and queue 2 shown).

[0089] Referring to Figure 4 , in step 401, the user may bind queue 1 and queue 2 (i.e., Figure 4 the active queues therein) to the passive queue (i.e., Figure 4in the sending queue) to indicate which task(s) in the passive queue the execution of the tasks in the passive queue need to wait for to complete. The network interface device of the current node can use the mapping table to store the association between the sending queue and Queues 1 and 2, and monitor the execution status of the tasks in at least Queues 1 and 2 bound to the sending queue when processing the trigger execution of the tasks in the sending queue. Additionally, note that there are no restrictions on the occurrence time and order of Step 401 for the bound queues, as long as it is done before the network interface device needs to know this information.

[0090] As Figure 4 shown in Step 402 of, the user can pre-submit sending tasks in the sending queue through the application running on the processor of the current node. The user can also submit blocking tasks to instruct the network interface device to block the sending tasks. The submission order can be to first submit the blocking tasks in the sending queue and then submit the sending tasks, so that there are sending tasks in the sending queue. In this way, the network interface device can know when processing the blocking tasks that the sending tasks need to be blocked to suspend execution. Of course, this order is only an example and not a limitation. The method of blocking the sending tasks is not limited to submitting blocking tasks, and can also be done by setting common parameters and other ways to notify the network interface device, which will not be described one by one here. However, the method of using the blocking tasks in the sending queue can enable the network interface device to suspend all subsequent tasks in the sending queue as expected when processing the tasks in the sending queue in sequence, without the need for additional instructions.

[0091] The user can set parameters through the application running on the processor of the current node, such as the de-trigger condition parameter trigger_count or the trigger condition parameter chaining_count, and this parameter can be carried in the blocking tasks.

[0092] The network interface device can respond to the first task queue (e.g., Figure 4 the passive queue or the sending queue in ) having a first task (e.g., Figure 4 the sending task in ) to block the execution of the first task (e.g., Figure 4 the sending task in ).

[0093] The network interface device can respond to at least one second task queue (e.g., Figure 4 the active queue in ) being bound to the first task queue (e.g., Figure 4 the passive queue or the sending queue in ) to determine the de-trigger condition for the blocking of the execution of the first task ( Figure 4 the sending task in ). The de-trigger condition can be based on the execution information of the tasks in at least one second task queue (e.g., Figure 4 the active queue in ).

[0094] AsFigure 4 As shown in step 403, the determination of the unblocking - triggering condition for the execution of the first task may include: determining the unblocking - triggering condition parameter trigger_count of the first task.

[0095] Alternatively, the determination of the unblocking - triggering condition for the execution of the first task may include: determining the unblocking - triggering condition parameter trigger_count of the first task based on the triggering condition parameter chaining_count.

[0096] The network interface device (or its driver) may obtain chaining_count from the information carried in the blocked task when processing the blocked task, and then set the unblocking - triggering condition of the sending task, such as setting the unblocking - triggering condition parameter trigger_count.

[0097] Of course, if the user carries the unblocking - triggering condition parameter trigger_count in the blocked task, the network interface device may directly determine the unblocking - triggering condition parameter trigger_count as the unblocking - triggering condition.

[0098] In summary, after the processor submits a task, the processor does not need to poll whether the tasks in the active queue are completed. Then, the network interface device will automatically block, resume, and execute the sending task based on the determined unblocking - triggering condition.

[0099] Note that the network interface device may obtain one or more corresponding unblocking - triggering condition parameters trigger_count of the sending tasks in the sending queue, and start to process the corresponding sending tasks one by one based on the corresponding unblocking - triggering condition parameters trigger_count.

[0100] Next, in step 404, the network interface device may block the execution of the sending task in response to the sending queue having a sending task.

[0101] As Figure 4 shown, the network interface device may start to process the blocked tasks in the sending queue, block the execution of the sending tasks in the sending queue, and obtain the unblocking - triggering condition (such as the trigger_count parameter) for the sending task.

[0102] In step 405, in order to block the execution of the sending task, the network interface device may mark the sending queue as a pending state and suspend responding to the sending queue (including suspending responding to the sending task and other subsequent tasks in the sending queue in the sending queue). For example, the network interface device may suspend responding to the knocking operation of the sending queue, such as suspending responding to the register value in the doorbell register of the sending queue.

[0103] Since the network interface device determines not to respond to the transmit queue, the network interface device does not need to continuously respond to the register value in the doorbell register to poll the tasks in the transmit queue, which can avoid occupying the resources of the network interface device and prevent tasks that are truly not blocked and need to be processed from being delayed. As a result, the network interface device can quickly process the tasks that truly need to be processed, improving the overall operating efficiency.

[0104] The network interface device can respond to determining that the de-trigger condition is satisfied, lift the execution block on the transmit task, and trigger the execution of the transmit task.

[0105] To determine that the de-trigger condition is satisfied, the network interface device can determine the execution information of the tasks in the active queue and, based on the execution information, determine whether the de-trigger condition is satisfied.

[0106] In Figure 4 step 406, the network interface device can maintain an execution information parameter completion_counter for the active queue. The parameter completion_counter can indicate how many second tasks in total in the active queue have been actually executed and completed. The parameter completion_counter can be initialized to 0 after the active queue is bound to the transmit queue and before the receive tasks in the active queue start to be executed. If each receive task is actually executed and completed once, the parameter completion_counter is incremented by one.

[0107] For example, in Figure 4 step 407, the network interface device can, in response to the parameter completion_counter being greater than or equal to the parameter trigger_count, process the blocked tasks corresponding to the transmit task to resume the execution of the transmit task. The network interface device can mark the transmit queue as the normal state and resume responding to the transmit queue to start processing the blocked tasks corresponding to the transmit task and subsequent tasks.

[0108] In this way, the network interface device can understand the trigger conditions of each task in the transmit queue. In the actual execution process, the network interface device can automatically count the received tasks that are actually executed according to the quantity information to automatically trigger the execution of the corresponding tasks in the transmit queue, greatly improving the execution efficiency.

[0109] Figure 5 FIG. shows a block diagram of a task processing apparatus 500 according to at least one embodiment of the present disclosure.

[0110] As Figure 5As shown, the task processing device 500 includes a blocking unit 510, a determination unit 520, and a triggering unit 530.

[0111] The blocking unit 510 is configured to block the execution of a first task in response to the first task queue having the first task.

[0112] The determination unit 520 is configured to determine a release-trigger condition for the blocked execution of the first task in response to at least one second task queue being bound to the first task queue. The release-trigger condition is based on the execution information of the tasks in at least one second task queue.

[0113] The triggering unit 530 is configured to release the block on the execution of the first task and trigger the execution of the first task in response to determining that the release-trigger condition is satisfied.

[0114] For example, in some embodiments, the first task queue includes one or more sending tasks for sending object data from the current node to the first node, and the sending task includes the first task.

[0115] For example, in some embodiments, at least one of the at least one second task queue includes one or more receiving tasks for the current node to receive object data from the second node.

[0116] For example, in some embodiments, the blocking unit 510 is configured to: block the execution of the first task based on the blocking task corresponding to the first task in the first task queue. The triggering unit 530 is configured to: process the blocking task corresponding to the first task to resume the execution of the first task.

[0117] For example, in some embodiments, the blocking unit 510 is configured to: identify the first task queue as the first state and suspend responding to the first task queue. The triggering unit 530 is configured to: identify the first task queue as the second state and resume responding to the first task queue to process the blocking task corresponding to the first task.

[0118] For example, in some embodiments, the blocking unit 510 is configured to: suspend the knocking operation for responding to the first task queue.

[0119] For example, in some embodiments, the determination unit 520 is configured to: determine the release-trigger condition parameter trigger_count of the first task.

[0120] For example, in some embodiments, the determination unit 520 is configured to: determine the release-trigger condition parameter trigger_count of the first task based on the trigger condition parameter chaining_count.

[0121] For example, in some embodiments, the trigger unit 530 is configured to: determine execution information of a second task in at least one second task queue; and determine whether the release-trigger condition is satisfied based on the execution information.

[0122] For example, in some embodiments, the trigger unit 530 is configured to: in response to the execution information indicating that the number of completed second tasks is greater than or equal to the release-trigger condition parameter, determine that the release-trigger condition is satisfied.

[0123] For example, in some embodiments, the task processing device 500 further includes: a storage device (not shown) configured to store an association relationship between the first task queue and at least one second task queue in response to at least one second task queue being bound to the first task queue.

[0124] For example, in some embodiments, the storage device is configured to: use a mapping table to store an association relationship between the first task queue and at least one second task queue.

[0125] The blocking unit 510, determining unit 520, and triggering unit 530 may be implemented, for example, by software, hardware, firmware, or any combination thereof, such as by digital circuits, or by a processing unit and a storage unit storing executable instructions.

[0126] In one or more of the above embodiments of the present disclosure, in response to the first task queue having the first task, the execution of the first task is blocked, so that the processor or other hardware of the computing node suspends processing or polling the first task queue. In response to at least one second task queue being bound to the first task queue, a release-trigger condition for blocking the execution of the first task based on the execution information of the tasks in the at least one second task queue is determined, thereby determining that triggering the execution of the tasks in the first task queue is related to the execution status of the tasks in the at least one second task queue. Until it is determined that the release-trigger condition is met, the execution of the first task is unblocked and the execution of the first task is triggered, avoiding the control and participation of the processor, thereby improving execution efficiency and reducing latency.

[0127] Figure 6 An electronic device (eg, including) suitable for implementing at least one embodiment of the present disclosure is shown. Figure 5 A structural diagram of the task processing device (600) in FIG.

[0128] The electronic device in the embodiments of the present disclosure can be applied to mobile terminals including but not limited to mobile phones, laptop computers, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Tablet Computers), PMPs (Portable Multimedia Players), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, servers, etc. For example, it can be used to implement a computing node, thereby executing the task processing method of any of the above embodiments. Figure 6 The illustrated electronic device is merely an example and should not impose any limitations on the functions and usage scope of the embodiments of the present disclosure.

[0129] As Figure 6 shown, the electronic device 600 may include a processing device (such as a central processing unit, a graphics processing unit, etc.) 601, which can perform various appropriate actions and processes according to the program stored in the read-only memory (ROM) 602 or the program loaded from the storage device 606 into the random access memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the electronic device 600 are also stored, including but not limited to an operating system, application programs, etc. The processing device 601, the ROM 602, and the RAM 603 are connected to each other through a bus 604. The input / output (I / O) interface 605 is also connected to the bus 604.

[0130] Generally, the following devices can be connected to the I / O interface 605: an input device 606 including, for example, a touch screen, a touchpad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; an output device 607 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; a storage device 606 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 609. The communication device 609 can allow the electronic device 600 to communicate with other devices wirelessly or wireline to exchange data. For example, it can include a network card, a modem, etc., and the communication device 609, for example, works in cooperation with a driver running on the processing device 601.

[0131] Although Figure 6 the electronic device 600 with various devices is shown, it should be understood that it is not required to implement or have all the shown devices. Instead, more or fewer devices can be implemented or had.

[0132] In particular, according to embodiments of the present disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product that includes a computer program carried on a non-transitory computer-readable medium, and the computer program includes program code for performing the methods shown in the flowcharts. In such an embodiment, the computer program can be downloaded and installed from a network via a communication device 609, or installed from a storage device 606, or installed from a ROM 602. When the computer program is executed by a processing device 601, the above-mentioned functions defined in the methods of the embodiments of the present disclosure are performed.

[0133] It should be noted that the above-mentioned computer-readable medium in the present disclosure can be a computer-readable signal medium or a computer-readable storage medium or any combination of the two. A computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the above. More specific examples of a computer-readable storage medium can include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium can be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. And in the present disclosure, a computer-readable signal medium can include a data signal propagated in a baseband or as part of a carrier wave, which carries computer-readable program code. Such a propagated data signal can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium, and the computer-readable signal medium can send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted by any appropriate medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

[0134] In some embodiments, the client and the server can communicate using any currently known or future-developed network protocol such as HTTP (HyperText Transfer Protocol), and can be interconnected with digital data communication in any form or medium (e.g., a communication network). Examples of communication networks include local area networks ("LANs"), wide area networks ("WANs"), the Internet (e.g., the Internet), and end-to-end networks (e.g., ad hoc end-to-end networks), as well as any currently known or future-developed networks.

[0135] The above computer-readable medium can be included in the above task processing device; or it can exist separately without being assembled into the task processing device.

[0136] The above computer-readable medium carries one or more programs / computer-executable codes. When the above one or more programs / computer-executable codes are executed by a processing device (e.g., a processor), the processing device is caused to perform the operations of the embodiments of the present disclosure.

[0137] Alternatively, the above computer-readable medium carries one or more programs / computer-executable codes. When the above one or more programs / computer-executable codes are executed by the task processing device, the task processing device is caused to perform the operations of the present disclosure.

[0138] Computer program code for performing the operations of the present disclosure can be written in one or more programming languages or combinations thereof. The above programming languages include, but are not limited to, object-oriented programming languages such as Java, Smalltalk, C++, and also include conventional procedural programming languages such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, executed as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer through any type of network - including a local area network (LAN) or a wide area network (WAN) - or can be connected to an external computer (e.g., by using an Internet service provider to connect through the Internet).

[0139] The flowcharts and block diagrams in the accompanying drawings illustrate the possible architectures, functions, and operations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagram may represent a module, a segment of a program, or a part of code that contains one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions noted in the blocks may occur in a different order than noted in the accompanying drawings. For example, two consecutive blocks shown may actually be executed substantially in parallel, or they may sometimes be executed in the reverse order, depending on the functions involved. It should also be noted that each block in the block diagram and / or flowchart, and combinations of blocks in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system that performs the specified functions or operations, or by a combination of dedicated hardware and computer instructions.

[0140] The units described in the embodiments of the present disclosure can be implemented in software or in hardware. In some cases, the name of the unit does not constitute a limitation on the unit itself.

[0141] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that can be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on a chip (SOCs), complex programmable logic devices (CPLDs), and so on.

[0142] In the context of the present disclosure, a machine-readable medium can be a tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

[0143] In summary, the present disclosure provides the following embodiments and examples:

[0144] Example 1. A task processing method, comprising:

[0145] In response to the first task queue having a first task, blocking execution of the first task;

[0146] In response to at least one second task queue being bound to the first task queue, determining a release-triggering condition for blocking execution of the first task, wherein the release-triggering condition is based on execution information of tasks in the at least one second task queue;

[0147] In response to determining that the unblocking-triggering condition is satisfied, unblocking the execution of the first task and triggering the execution of the first task.

[0148] Example 2. A task processing method according to Example 1, wherein the first task queue includes one or more sending tasks for sending object data from a current node to a first node, and the sending tasks include the first task.

[0149] Example 3. A task processing method according to Example 1, wherein the first task queue includes one or more receiving tasks for a current node to receive object data from a first node, and the one or more receiving tasks include the first task.

[0150] Example 4. The task processing method according to Example 2 or 3, wherein:

[0151] At least one of the at least one second task queues includes one or more receiving tasks for the current node to receive the object data from a second node.

[0152] Example 5. The task processing method according to Example 2 or 3, wherein:

[0153] At least one of the at least one second task queues includes one or more sending tasks for the current node to send object data to a third node.

[0154] Example 6. The task processing method according to Example 1, wherein:

[0155] The blocking the execution of the first task comprises: blocking the execution of the first task based on a blocking task corresponding to the first task in the first task queue;

[0156] The unblocking of the execution of the first task and triggering the execution of the first task includes: processing the blocked task corresponding to the first task to resume the execution of the first task.

[0157] Example 7. The task processing method according to Example 6, wherein:

[0158] The blocking the execution of the first task further includes: marking the first task queue as a first state and suspending response to the first task queue;

[0159] The unblocking of the execution of the first task and triggering the execution of the first task further includes: marking the first task queue as a second state, and resuming response to the first task queue to process the blocked task corresponding to the first task.

[0160] Example 8. The task processing method according to Example 7, wherein the pausing response to the first task queue comprises:

[0161] The knock operation of responding to the first task queue is suspended.

[0162] Example 9. The task processing method according to any one of Examples 1-3, wherein determining a release-triggering condition for blocking execution of the first task comprises:

[0163] Determine a release-trigger condition parameter of the first task.

[0164] Example 10. The task processing method according to any one of Examples 1-3, wherein determining a triggering condition for unblocking execution of the first task comprises:

[0165] A release-triggering condition parameter of the first task is determined based on the triggering condition parameter.

[0166] Example 11. The task processing method according to any one of Examples 1-3, wherein the determining that the release-trigger condition is satisfied comprises:

[0167] Determining execution information of a second task in the at least one second task queue;

[0168] Based on the execution information, it is determined whether the release-trigger condition is satisfied.

[0169] Example 12. The task processing method according to Example 11, wherein determining whether the release-trigger condition is satisfied based on the execution information comprises:

[0170] In response to the execution information indicating that the number of the second tasks that have been executed is greater than or equal to the release-triggering condition parameter, it is determined that the release-triggering condition is satisfied.

[0171] Example 13. The task processing method according to any one of Examples 1-3, further comprising:

[0172] In response to the at least one second task queue being bound to the first task queue, an association relationship between the first task queue and the at least one second task queue is stored.

[0173] Example 14. The task processing method according to Example 13, wherein storing the association relationship between the first task queue and the at least one second task queue includes:

[0174] Storing the association relationship between the first task queue and the at least one second task queue using a mapping table.

[0175] Example 15. A task processing apparatus, comprising:

[0176] A blocking unit configured to block the execution of a first task in response to the first task queue having a first task;

[0177] A determining unit configured to determine, in response to at least one second task queue being bound to the first task queue, a de-blocking trigger condition for the execution of the first task, wherein the de-blocking trigger condition is based on execution information of tasks in the at least one second task queue;

[0178] A triggering unit configured to de-block the execution of the first task and trigger the execution of the first task in response to determining that the de-blocking trigger condition is satisfied.

[0179] Example 16. The task processing apparatus according to Example 15, wherein the first task queue includes one or more sending tasks for sending object data from a current node to a first node, and the sending task includes the first task.

[0180] Example 17. The task processing apparatus according to Example 15, wherein the first task queue includes one or more receiving tasks for the current node to receive object data from a first node, and the one or more receiving tasks include the first task.

[0181] Example 18. The task processing apparatus according to Example 16 or 17, wherein

[0182] At least one of the at least one second task queues includes one or more receiving tasks for the current node to receive the object data from a second node.

[0183] Example 19. The task processing apparatus according to Example 16 or 17, wherein

[0184] At least one of the at least one second task queues includes one or more sending tasks for the current node to send object data to a third node.

[0185] Example 20. The task processing apparatus according to Example 15, wherein

[0186] The blocking unit is configured to: block the execution of the first task based on the blocking task corresponding to the first task in the first task queue;

[0187] The triggering unit is configured to: process the blocking task corresponding to the first task to resume the execution of the first task.

[0188] Example 21. The task processing device according to Example 20, wherein,

[0189] The blocking unit is configured to: identify the first task queue as the first state and suspend responding to the first task queue;

[0190] The triggering unit is configured to: identify the first task queue as the second state and resume responding to the first task queue to process the blocking task corresponding to the first task.

[0191] Example 22. The task processing device according to Example 21, wherein the blocking unit is configured to:

[0192] Suspend responding to the knocking operation of the first task queue.

[0193] Example 23. The task processing device according to any one of Examples 15-17, wherein the determining unit is configured to:

[0194] Determine the release-trigger condition parameter of the first task.

[0195] Example 24. The task processing device according to any one of Examples 15-17, wherein the determining unit is configured to:

[0196] Determine the release-trigger condition parameter of the first task based on the trigger condition parameter.

[0197] Example 25. The task processing device according to Example 15, wherein the determining unit is configured to:

[0198] Determine the execution information of the second task in the at least one second task queue;

[0199] Based on the execution information, determine whether the release-trigger condition is satisfied.

[0200] Example 26. The task processing device according to Example 25, wherein the determining unit is configured to:

[0201] In response to the number of the second tasks indicating execution completion in the execution information being greater than or equal to the release-trigger condition parameter, determine that the release-trigger condition is satisfied.

[0202] Example 27. The task processing device according to any one of Examples 15-17 further includes:

[0203] A storage unit configured to store the association relationship between the first task queue and the at least one second task queue in response to the at least one second task queue being bound to the first task queue.

[0204] Example 28. The task processing device according to Example 27, wherein the storage unit is configured to:

[0205] Store the association relationship between the first task queue and the at least one second task queue using a mapping table.

[0206] Example 29. A task processing device includes:

[0207] A storage device storing computer instructions;

[0208] At least one processing device configured to execute the computer instructions in the storage device to perform the task processing method according to any one of Examples 1-14.

[0209] Example 30. A non-transitory computer-readable storage medium storing computer instructions,

[0210] wherein when the computer instructions are executed by a processor, the processor is caused to perform the task processing method according to any one of Examples 1-14.

[0211] The above description is only a preferred embodiment of the present disclosure and an explanation of the applied technical principles. Those skilled in the art should understand that the scope of disclosure involved in the present disclosure is not limited to the technical solutions formed by the specific combination of the above technical features, and should also cover other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the above disclosure concept. For example, the technical solutions formed by mutually replacing the above features with the technical features (but not limited to) having similar functions disclosed in the present disclosure.

[0212] In addition, although the operations are depicted in a specific order, this should not be construed as requiring the operations to be performed in the specific order shown or in sequential order. In certain environments, multitasking and parallel processing may be advantageous. Similarly, although several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features described in the context of separate embodiments can also be implemented combinatorially in a single embodiment. Conversely, the various features described in the context of a single embodiment can also be implemented separately or in any suitable sub-combination in multiple embodiments.

[0213] Although the subject matter has been described in language specific to structural features and / or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. On the contrary, the specific features and acts described above are merely example forms for implementing the claims.

Claims

1. A task processing method, comprising: In response to the first task queue having a first task, blocking execution of the first task; In response to at least one second task queue being bound to the first task queue, determining a release-triggering condition for blocking execution of the first task, wherein the release-triggering condition is based on execution information of tasks in the at least one second task queue; In response to determining that the unblocking-triggering condition is satisfied, unblocking the execution of the first task and triggering the execution of the first task.

2. The task processing method according to claim 1, wherein: The first task queue includes one or more sending tasks for sending object data from the current node to the first node, and the one or more sending tasks include the first task.

3. The task processing method according to claim 1, wherein: The first task queue includes one or more receiving tasks for a current node to receive object data from a first node, and the one or more receiving tasks include the first task.

4. The task processing method according to claim 2 or 3, wherein: At least one of the at least one second task queues includes one or more receiving tasks for the current node to receive the object data from a second node.

5. The task processing method according to claim 2 or 3, wherein: At least one of the at least one second task queues includes one or more sending tasks for the current node to send object data to a third node.

6. The task processing method according to claim 1, wherein: The blocking the execution of the first task comprises: blocking the execution of the first task based on a blocking task corresponding to the first task in the first task queue; The unblocking of the execution of the first task and triggering the execution of the first task includes: processing the blocked task corresponding to the first task to resume the execution of the first task.

7. The task processing method according to claim 6, wherein: The blocking the execution of the first task further includes: marking the first task queue as a first state and suspending response to the first task queue; The unblocking of the execution of the first task and triggering the execution of the first task further includes: marking the first task queue as a second state, and resuming response to the first task queue to process the blocked task corresponding to the first task.

8. The task processing method according to claim 7, wherein: The pausing response to the first task queue includes: The knock operation of responding to the first task queue is suspended.

9. The task processing method according to any one of claims 1 to 3, wherein: The determining of a triggering condition for releasing the execution block of the first task includes: Determine a release-trigger condition parameter of the first task.

10. The task processing method according to any one of claims 1 to 3, wherein: The determining of a triggering condition for releasing the execution block of the first task includes: A release-triggering condition parameter of the first task is determined based on the triggering condition parameter.

11. The task processing method according to any one of claims 1 to 3, wherein: The determining that the release-triggering condition is satisfied includes: Determining execution information of a second task in the at least one second task queue; Based on the execution information, it is determined whether the release-trigger condition is satisfied.

12. The task processing method according to claim 11, wherein: The determining, based on the execution information, whether the release-trigger condition is satisfied comprises: In response to the execution information indicating that the number of the second tasks that have been executed is greater than or equal to the release-triggering condition parameter, it is determined that the release-triggering condition is satisfied.

13. The task processing method according to any one of claims 1 to 3, further comprising: In response to the at least one second task queue being bound to the first task queue, an association relationship between the first task queue and the at least one second task queue is stored.

14. The task processing method according to claim 13, wherein: The storing the association relationship between the first task queue and the at least one second task queue includes: A mapping table is used to store an association relationship between the first task queue and the at least one second task queue.

15. A task processing device, comprising: a blocking unit, configured to, in response to the first task queue having a first task, block execution of the first task; a determining unit configured to determine, in response to at least one second task queue being bound to the first task queue, a release-triggering condition for blocking execution of the first task, wherein the release-triggering condition is based on execution information of tasks in the at least one second task queue; The triggering unit is configured to, in response to determining that the release-triggering condition is satisfied, release the blocking of the execution of the first task and trigger the execution of the first task.

16. A task processing device, comprising: a storage device storing computer instructions; At least one processing device is configured to execute the computer instructions in the storage device to perform the task processing method according to any one of claims 1-14.

17. A non-transitory computer readable storage medium having computer instructions stored thereon, in, When the computer instructions are executed by a processor, the processor is caused to perform the task processing method according to any one of claims 1 to 14.

Images