An order task splitting and reorganizing processing method and device and a storage medium

Abstract

This application discloses a method, apparatus, and storage medium for order task splitting and reorganization. The method includes: constructing an order processing flow model based on the order information of the orders to be processed; dividing the order processing flow into multiple independently executable first subtasks, and calculating a first priority, a first dependency matrix, and a resource consumption vector for each first subtask; obtaining resource status information, and based on the resource status information and the resource consumption vector of the first subtasks, executing a pre-configured merging and splitting algorithm to generate a second subtask adapted to the fulfillment node; updating the first priority and the first dependency matrix to obtain a third subtask containing a second priority and a second dependency matrix; executing a pre-configured reorganization algorithm to generate at least one task processing sequence; calculating the path score of each execution path in the task processing sequence, and determining the target execution path based on the path score.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a method, apparatus and storage medium for processing order task splitting and reassembly. Background Technology

[0002] With the rapid development of e-commerce, e-commerce platforms need to process a large number of orders every day. These orders usually involve multiple processing stages such as payment, inventory allocation, logistics scheduling, and risk control review, and there are certain dependencies between these stages.

[0003] Existing order processing methods mostly employ fixed workflows or static priority-based scheduling, making it difficult to flexibly schedule processes based on their dynamic states. Under high concurrency or multi-stage dependencies, these methods may lead to reduced processing efficiency or uneven resource utilization.

[0004] Therefore, existing technologies still fall short in efficiently and stably processing large volumes of orders while taking into account the dependencies between order stages, and new methods are needed to improve the management and scheduling of order processing flows. Summary of the Invention

[0005] To address the aforementioned technical problems, this application provides a method, apparatus, and storage medium for processing order task splitting and reassembly.

[0006] The technical solution provided in this application is described below:

[0007] The first aspect of this application provides a method for splitting and recombining order tasks, including:

[0008] An order processing flow model is constructed based on the order information of the orders to be processed. The order processing flow model is used to describe the execution relationship between each processing step in the order processing process and to map the processing step to the corresponding fulfillment node.

[0009] According to the order processing flow model, the order processing flow is divided into multiple independently executable first subtasks, and a first priority, a first dependency matrix, and a resource consumption vector are calculated for each first subtask. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks.

[0010] Obtain resource status information, and based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node;

[0011] Based on the node status information of the second subtask and the corresponding fulfillment node, the first priority and the first dependency matrix are updated to obtain a third subtask containing the second priority and the second dependency matrix.

[0012] Based on the third subtask, the second dependency matrix, and the second priority, a pre-configured reorganization algorithm is executed to generate at least one task processing sequence, provided that the second dependency matrix is ​​satisfied.

[0013] Calculate the path score for each execution path in the task processing sequence, and determine the target execution path based on the path score.

[0014] Optionally, the step of updating the first priority and the first dependency matrix based on the second subtask and the node status information of the corresponding fulfillment node to obtain a third subtask containing a second priority and a second dependency matrix includes:

[0015] Obtain the node status information of the fulfillment node corresponding to the second subtask, wherein the node status information includes at least one of the node's current load, task queue length, and processing capacity per unit time.

[0016] Based on the node status information, calculate the node adaptation coefficient of the second subtask;

[0017] The first priority is adjusted based on the node adaptation coefficient to obtain the second priority;

[0018] Based on the node status information and the execution relationship between the second subtasks, the first dependency matrix is ​​modified to obtain the second dependency matrix;

[0019] The second subtask is associated with the corresponding second priority and second dependency matrix to generate the third subtask.

[0020] Optionally, calculating the node adaptation coefficient of the second subtask based on the node state information includes:

[0021] Construct the node load coefficient, queue length coefficient, and processing capacity coefficient for each fulfillment node;

[0022] Based on the resource consumption vector and expected execution time of the second subtask, calculate the resource occupancy intensity of the second subtask relative to the fulfillment node;

[0023] Based on the node load coefficient, queue length coefficient, processing capacity coefficient, and resource occupancy intensity, a combined weighted calculation is performed to obtain the node adaptation coefficient of the second subtask.

[0024] Optionally, based on the third subtask, the second dependency matrix, and the second priority, a pre-configured reorganization algorithm is executed to generate at least one task processing sequence, provided that the second dependency matrix is ​​satisfied, including:

[0025] The third subtask is initially sorted according to the second priority to obtain an initial task sequence;

[0026] Dependency constraint judgment is performed on the initial task sequence based on the second dependency matrix;

[0027] When a third subtask does not satisfy the preceding dependencies in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraints of the second dependency matrix are satisfied, thus obtaining a candidate task sequence.

[0028] Based on the parallel execution index of the third subtask and the node status information of the corresponding fulfillment node, the third subtask in the candidate task sequence is scheduled and allocated in parallel to generate at least one set of parallel execution subtasks.

[0029] The candidate task sequence is reordered based on the parallel execution subtasks to generate at least one task processing sequence that satisfies the dependency constraints.

[0030] Optionally, when a third subtask does not satisfy the preceding dependencies in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraints of the second dependency matrix are satisfied, resulting in a candidate task sequence, including:

[0031] A directed acyclic graph is constructed based on the second dependency matrix, where nodes in the directed acyclic graph represent the third subtasks and edges represent the dependencies between the third subtasks.

[0032] The in-degree of the directed acyclic graph is calculated, and the initial subtask of the target is determined based on the calculation result;

[0033] Based on the second priority, target subtasks are determined from the target initial subtasks and added to the candidate task sequence, and the nodes and outgoing edges corresponding to the target subtasks are removed from the directed acyclic graph.

[0034] Update the in-degree information of the remaining nodes in the directed acyclic graph, and redetermine the initial target subtask. Repeat the target subtask determination, addition, and node removal operations until all the third subtasks are added to the candidate task sequence.

[0035] Optionally, the step of obtaining resource status information and, based on the resource status information and the resource consumption vector of the first subtask, executing a pre-configured merging and splitting algorithm to generate a second subtask adapted to the fulfillment node includes:

[0036] Obtain resource status information for each fulfillment node;

[0037] Based on the resource consumption vector of the first subtask, calculate the resource occupancy level of each first subtask on the corresponding fulfillment node, and determine whether the resource occupancy level exceeds the preset resource threshold.

[0038] When the resource occupancy exceeds the preset resource threshold, the corresponding first subtask is divided into multiple subtask units, and the resource occupancy of the subtask unit is lower than the preset resource threshold.

[0039] When multiple first subtasks have dependencies and the sum of their corresponding resource consumption vectors is lower than a preset merging threshold, the multiple first subtasks are merged to generate a merged subtask.

[0040] Based on the subtask unit and the merged subtask, a second subtask is generated that is adapted to the resource capabilities of the fulfillment node.

[0041] Optionally, calculating the path score for each execution path in the task processing sequence and determining the target execution path based on the path score includes:

[0042] Obtain the execution path information corresponding to each task processing sequence. The execution path information includes the estimated execution time of each sub-task, the corresponding fulfillment node, and the task execution order.

[0043] Based on the execution path information, calculate the total estimated execution time of the execution path and the resource consumption of each fulfillment node;

[0044] Based on the resource consumption level, calculate the node load balancing index and task waiting time index of the execution path;

[0045] The execution path is comprehensively evaluated based on the total estimated execution time, node load balancing metrics, and task waiting time metrics to obtain a path score;

[0046] The path scores of each execution path are compared, and the target execution path is determined based on the comparison results.

[0047] Optionally, the step of dividing the order processing flow into multiple independently executable first subtasks according to the order processing flow model, and calculating a first priority, a first dependency matrix, and a resource consumption vector for each first subtask, includes:

[0048] The order processing flow model is analyzed, and each processing step in the order processing flow is extracted into a basic processing unit;

[0049] Based on the execution relationship between the basic processing units, the basic processing units are divided into multiple independently executable first subtasks;

[0050] Calculate the first priority of each first subtask;

[0051] Based on the execution relationship, construct the dependency relationship between the first subtasks and generate the first dependency matrix;

[0052] Calculate the resource consumption vector for each first subtask, which represents the amount of resources required for the first subtask to be executed at the fulfillment node.

[0053] The second aspect of this application provides a method for splitting and recombining order tasks, including:

[0054] The process model construction unit is used to construct an order processing process model based on the order information of the order to be processed. The order processing process model is used to describe the execution relationship between each processing step in the order processing process and to map the processing step to the corresponding fulfillment node.

[0055] The process division unit is used to divide the order processing process into multiple independently executable first subtasks according to the order processing process model, and to calculate a first priority, a first dependency matrix and a resource consumption vector for the first subtasks. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks.

[0056] The task splitting unit is used to obtain resource status information and, based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node.

[0057] The task update unit is used to update the first priority and the first dependency matrix based on the node status information of the second subtask and the corresponding fulfillment node, so as to obtain a third subtask containing the second priority and the second dependency matrix.

[0058] The sequence generation unit is used to execute a pre-configured recombination algorithm based on the third subtask, the second dependency matrix, and the second priority, and generate at least one task processing sequence under the premise of satisfying the second dependency matrix.

[0059] The path generation unit is used to calculate the path score of each execution path in the task processing sequence and determine the target execution path based on the path score.

[0060] A third aspect of this application provides an order task splitting and reorganization processing apparatus, the apparatus comprising:

[0061] Processor, memory, input / output units, and bus;

[0062] The processor is connected to the memory, the input / output unit, and the bus;

[0063] The memory stores a program, which the processor invokes to execute the first aspect and any one of the optional methods in the first aspect.

[0064] A fourth aspect of this application provides a computer-readable storage medium on which a program is stored, which, when executed on a computer, performs the methods of the first aspect and any one of the first aspects.

[0065] As can be seen from the above technical solutions, this application has the following beneficial effects:

[0066] This application provides a structured representation of the order processing process based on an order processing workflow model, mapping processing steps to fulfillment nodes. On this basis, the order processing workflow is divided into multiple first sub-tasks, and priority, dependency matrices, and resource consumption vectors are established, transforming order processing from a linear process into a computable task structure. By introducing resource status information from fulfillment nodes, the first sub-tasks are split and merged to generate second sub-tasks adapted to the node's resource capabilities, thus matching task granularity with system resource status. The priority and dependency matrices are dynamically updated based on node status to form third sub-tasks, ensuring that the execution relationships between tasks are not only constrained by the business process but also reflect changes in the system's operating status.

[0067] This application further reorganizes tasks based on the updated dependency matrix and priority, generates a task processing sequence under the premise of satisfying dependency constraints, and determines the target execution path by comprehensively evaluating different execution paths. This makes the task scheduling result take into account both execution order constraints and resource utilization, thereby improving the overall order processing efficiency, resource utilization and processing stability. Attached Figure Description

[0068] To more clearly illustrate the technical solutions in this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0069] Figure 1This is a schematic flowchart of an embodiment of the order task splitting and reorganization processing method provided in this application;

[0070] Figure 2 This is a schematic flowchart of an embodiment of step S103 in the order task splitting and reorganization processing method provided in this application;

[0071] Figure 3 This is a schematic flowchart of an embodiment of step S104 in the order task splitting and reorganization processing method provided in this application;

[0072] Figure 4 This is a schematic flowchart of an embodiment of step S105 in the order task splitting and reorganization processing method provided in this application;

[0073] Figure 5 A schematic diagram of an embodiment of the order task splitting and recombining processing apparatus provided in this application;

[0074] Figure 6 This is a schematic diagram of an embodiment of another order task splitting and recombining processing apparatus provided in this application. Detailed Implementation

[0075] In embodiments of the present invention, the executing entity of the order task splitting and reassembly processing method is not specifically limited, and it can be implemented collaboratively by one or more computing devices. The computing device can be a server, a cloud computing platform, a distributed computing node, or other devices with data processing capabilities.

[0076] Specifically, the steps in the method can be executed by the same processing unit or by multiple processing units in a distributed manner; the processing units can be deployed on the same physical device or on different physical devices and connected via a network. Steps involving order processing workflow modeling, task partitioning, task reorganization, and path evaluation can be implemented by different functional modules, which can be implemented as software programs, hardware circuits, or a combination of both.

[0077] Furthermore, the fulfillment node can exist as a business node that actually executes order processing tasks, or as a logical abstract node, used to represent a resource unit with specific processing capabilities, and its specific implementation form is not limited.

[0078] It should be understood that the above-mentioned configuration of the execution subject is merely an example, and the present invention is not limited thereto. Any equivalent substitution or transformation of the specific implementation form of the execution subject without affecting the implementation of the technical solution of the present invention shall fall within the protection scope of the present invention.

[0079] The order task splitting and reorganization processing method provided by this invention is applicable to order processing scenarios with multiple processing stages, multiple resource nodes and complex dependencies, and is especially applicable to order processing processes in e-commerce platforms, instant retail systems and supply chain fulfillment systems.

[0080] In typical application scenarios, order processing usually includes multiple processing stages such as payment confirmation, inventory locking, order review, warehouse allocation, and logistics scheduling. Different processing stages are executed by different fulfillment nodes, and there are certain execution dependencies between each processing stage. At the same time, under high concurrency, the resource status of each fulfillment node (such as processing capacity, current load, queuing status, etc.) will change dynamically, which can easily lead to some nodes being congested while others are idle, thereby affecting the overall order processing efficiency.

[0081] In the above scenario, the present invention models the order processing flow, divides the order processing process into multiple independently executable sub-tasks, and combines the resource status information of the fulfillment nodes to split and merge the sub-tasks, so that the task granularity matches the node processing capacity; furthermore, by dynamically updating the task priority and dependencies, and reorganizing and scheduling the tasks, a task processing sequence is generated under the premise of satisfying the dependency constraints, thereby realizing the dynamic optimization of the order processing process.

[0082] For example, in an e-commerce order fulfillment scenario involving multiple warehouse nodes, when a warehouse node is under high load, this invention can split the inventory processing tasks originally concentrated on that node and distribute them to multiple warehouse nodes with lower loads. Alternatively, when multiple orders have similar processing paths and low resource consumption, the corresponding sub-tasks can be merged for processing, thereby reducing scheduling overhead. Based on this, by evaluating different task processing sequences, a better execution path is selected, enabling the order processing process to meet business constraints while improving resource utilization efficiency and reducing processing latency.

[0083] Therefore, this invention can adapt to the needs of dynamic resource changes in complex order processing scenarios, realize the reasonable allocation and scheduling of order processing tasks among multiple fulfillment nodes, and has good versatility and scalability.

[0084] The embodiments in this application are described in detail below:

[0085] Please see Figure 1 This application first provides an embodiment of an order task splitting and reorganization processing method, which includes:

[0086] S101. Construct an order processing flow model based on the order information of the orders to be processed, wherein the order processing flow model is used to describe the execution relationship between each processing step in the order processing process, and maps the processing step to the corresponding fulfillment node;

[0087] An order processing flow model is constructed based on the order information of the orders to be processed, wherein the order information may include order product information, order type, delivery method, and order priority.

[0088] Specifically, the order processing process can be broken down into multiple processing steps based on the business workflow, such as payment confirmation, inventory locking, order review, warehouse allocation, and logistics scheduling. A process model can then be constructed based on the sequential relationships between these processing steps. During the construction process, a graph structure or process structure can be used to describe the execution relationships between the processing steps, where each processing step corresponds to a node, and the sequential execution relationships between processing steps correspond to edges.

[0089] At the same time, each processing step is mapped to the corresponding fulfillment node. For example, the inventory processing step is mapped to the inventory node, the order review step is mapped to the risk control node, and the logistics scheduling step is mapped to the logistics node, thereby establishing a correspondence between processing steps and execution resources.

[0090] S102. According to the order processing flow model, the order processing flow is divided into multiple independently executable first subtasks, and a first priority, a first dependency matrix and a resource consumption vector are calculated for the first subtasks. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks.

[0091] Based on the order processing flow model, the order processing flow is divided into multiple independently executable first subtasks. Specifically, based on the functional independence and execution boundaries of the processing steps, one or more processing steps can be combined into a subtask, so that the subtask can be executed independently without depending on other incomplete subtasks.

[0092] After completing the subtask division, the following parameters are calculated for each first subtask:

[0093] (1) First priority:

[0094] The priority can be calculated based on factors such as the urgency of the order, the processing stage of the subtask, and the expected execution time. For example, the priority of a subtask in a critical path or a high-priority order can be set higher.

[0095] (2) First dependency matrix:

[0096] Used to describe the execution constraints between each first subtask. For example, if subtask B can only be executed after subtask A is completed, then the corresponding dependency relationship is established in the dependency matrix.

[0097] (3) Resource consumption vector:

[0098] This resource consumption vector is used to characterize the amount of resources required for the execution of each first subtask, such as computing resources, inventory resources, or processing time. This resource consumption vector can be estimated based on historical order processing data.

[0099] In a specific embodiment, dividing the order processing flow into multiple independently executable first subtasks may include the following process: parsing the order processing flow model and extracting each processing step in the order processing flow into a basic processing unit; dividing the basic processing unit into multiple independently executable first subtasks according to the execution relationship between the basic processing units; calculating the first priority of each first subtask; constructing the dependency relationship between the first subtasks according to the execution relationship and generating a first dependency matrix; calculating the resource consumption vector of each first subtask, wherein the resource consumption vector is used to characterize the amount of resources required by the first subtask when it is executed at the fulfillment node.

[0100] Specifically, each independent processing step can be identified from the order processing workflow model, such as payment confirmation, inventory locking, order review, warehouse allocation, and logistics scheduling, and each processing step can be identified as a basic processing unit. Simultaneously, the input-output relationships and execution sequence between these basic processing units can be recorded for subsequent task division.

[0101] After obtaining the basic processing units, the basic processing units are divided into multiple independently executable first subtasks according to the execution relationships between them. Specifically, the division can be based on the degree of dependency and functional coupling between the basic processing units. Basic processing units with weak dependencies and capable of independent execution can be divided into different first subtasks; for multiple basic processing units with close dependencies or requiring continuous execution, they can be combined to form the same first subtask, thereby ensuring that each first subtask has clear input and output boundaries during execution.

[0102] Calculate the first priority for each first subtask. The priority of each first subtask can be assigned by comprehensively considering factors such as the urgency of the order, its position in the overall process, and its estimated execution time. For example, subtasks on the critical path or those corresponding to high-priority orders can be assigned a higher priority.

[0103] Furthermore, based on the execution relationships between the basic processing units, the dependencies between the first subtasks are constructed, and a first dependency matrix is ​​generated. Each first subtask can be treated as a node in the matrix, and the corresponding dependencies are marked in the matrix according to the sequential execution relationships between tasks, thereby forming a first dependency matrix to describe the task execution constraints. Through the first dependency matrix, it can be clearly determined which subtasks must be executed after other subtasks are completed.

[0104] In addition, it is necessary to calculate the resource consumption vector for each first subtask. Based on the processing stage type corresponding to the first subtask and historical order processing data, the amount of resources required during its execution can be estimated, such as processing time, computational resource usage, or inventory resource usage, and these resource requirements can be represented as a resource consumption vector. This resource consumption vector characterizes the degree of system resource demand of the first subtask when it is executed at the corresponding fulfillment node.

[0105] S103. Obtain resource status information, and based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node.

[0106] Obtain resource status information, and based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merge and split algorithm to generate the second subtask.

[0107] The resource status information may include the current load, available resources, and processing capacity of each fulfillment node. Specifically, when the resource consumption of a first subtask exceeds the current available resources of the corresponding fulfillment node, the first subtask can be split, for example, a single inventory processing task can be split into multiple subtasks to be executed on different warehouse nodes. When multiple first subtasks are related and have low resource consumption, they can be merged to reduce task scheduling overhead. Through the above splitting and merging processes, the generated second subtasks are made to better match the resource requirements of the current fulfillment node.

[0108] See Figure 2 In an optional embodiment, one way to construct the second subtask may include the following process:

[0109] S1031. Obtain the resource status information of each fulfillment node;

[0110] In this step, the operational status data of each fulfillment node can be collected from the order processing system. The resource status information may include the node's current load, available resources, task queue length, and processing capacity per unit time, which are used to characterize the resource availability of each fulfillment node at the current moment.

[0111] Specifically, operational status data for each fulfillment node can be collected from the order processing system. This resource status information may include the node's current load L. i Available resources R i Task queue length Q i And processing capacity per unit time C i Parameters, where i represents the i-th fulfillment node.

[0112] S1032. Based on the resource consumption vector of the first subtask, calculate the resource occupancy level of each first subtask at the corresponding fulfillment node, and determine whether the resource occupancy level exceeds a preset resource threshold.

[0113] The resource consumption vector of the first subtask is matched and calculated with the available resources of the corresponding fulfillment node to obtain the resource occupancy ratio or resource occupancy intensity of the first subtask on the fulfillment node, and then compared with the preset resource threshold to determine whether the first subtask is suitable to be executed directly on the current node.

[0114] Specifically, for the j-th first subtask, its resource consumption vector can be represented as:

[0115] ;

[0116] Each component represents the demand for different types of resources.

[0117] Resource usage can be calculated in the following way:

[0118] ;

[0119] in:

[0120] This indicates the resource consumption level of the j-th subtask at the i-th fulfillment node;

[0121] α and β are weighting coefficients used to balance the impact of resource consumption and queuing pressure.

[0122] when When the (preset resource threshold) is reached, the task is considered unsuitable for execution at the current granularity.

[0123] S1033. When the resource occupancy level exceeds the preset resource threshold, the corresponding first subtask is divided into multiple subtask units, and the resource occupancy level of the subtask unit is lower than the preset resource threshold.

[0124] In this step, the first subtask can be split according to dimensions such as the scale of data being processed, the number of objects being processed, or the scope of processing. This ensures that the resource consumption of each subtask unit during execution is lower than the preset resource threshold, allowing the split subtask units to be executed in parallel on multiple fulfillment nodes. For example, a large-volume inventory processing task can be divided into multiple small-volume processing tasks to reduce the resource consumption of a single task.

[0125] Specifically, the number of splits can be determined as follows:

[0126] ;

[0127] The j-th first subtask is divided into N j There are several sub-task units, ensuring that the resource consumption of each sub-task unit meets the following requirements:

[0128] ;

[0129] The splitting method can be based on data sharding, order subset partitioning, or processing scope partitioning, such as splitting a large batch of orders into multiple small batch tasks.

[0130] S1034. When there is a dependency relationship between multiple first subtasks and the sum of the corresponding resource consumption vectors is lower than a preset merging threshold, the multiple first subtasks are merged to generate a merged subtask.

[0131] Multiple low-resource-consumption, closely related subtasks can be merged and executed as a single task on the same fulfillment node to reduce task scheduling frequency and cross-node communication overhead. For example, consecutively executed order review and risk control verification tasks can be combined into a single processing unit.

[0132] For a set of tasks with dependencies, the resource consumption after merging can be calculated:

[0133] ;

[0134] ;

[0135] When satisfied In this case, the multiple first subtasks can be merged into a single merged subtask to reduce scheduling frequency and cross-node communication overhead.

[0136] S1035. Generate a second subtask based on the subtask unit and the merged subtask, which is adapted to the resource capabilities of the fulfillment node.

[0137] Based on the resource status information of each fulfillment node, the sub-task units obtained from the splitting and the merged sub-tasks are remapped and reassigned so that each second sub-task can be matched with the resource capabilities of the corresponding fulfillment node when it is executed, thereby forming a set of tasks that are more suitable for execution under the current system resource status.

[0138] This embodiment allows the original first subtask to be converted into a second subtask that dynamically matches the resource capabilities of the fulfillment node, making the task granularity and resource allocation more reasonable.

[0139] S104. Based on the node status information of the second subtask and the corresponding fulfillment node, update the first priority and the first dependency matrix to obtain a third subtask containing the second priority and the second dependency matrix.

[0140] Based on the node status information of the second subtask and the corresponding fulfillment node, the first priority and the first dependency matrix are updated to obtain the third subtask.

[0141] Specifically, the execution priority of the second subtask can be adjusted based on the real-time load status and task queuing information of each fulfillment node. For example, when a node has a high load, the priority of the subtasks assigned to that node can be appropriately reduced. Simultaneously, the original dependencies can be adjusted based on node processing capabilities and task execution conflicts. For instance, while meeting business constraints, some subtasks that were originally executed sequentially can be changed to be executed in parallel, thereby updating the dependency matrix. Through these updates, the execution order and priority of the third subtask can reflect the current operating status of the system.

[0142] See Figure 3 In an optional embodiment, the construction process of the third subtask can be implemented as follows:

[0143] S1041. Obtain the node status information of the fulfillment node corresponding to the second subtask. The node status information includes at least one of the node's current load, task queue length, and processing capacity per unit time.

[0144] The second subtask is an atomic execution task corresponding to a unique fulfillment node, which is pre-decomposed based on the main fulfillment process. The second subtask is pre-configured with an initial first priority and a first dependency matrix. The fulfillment node is a dedicated execution carrier for executing the second subtask, such as a hardware execution unit, service instance, business processing terminal, distributed cluster node, or business process link. For example, it is a warehouse sorting node, logistics distribution node, or financial settlement node in an order fulfillment system, or a production line execution node or data processing node in an industrial control system.

[0145] The node status information includes at least one of the following: current node load, task queue length, and processing capacity per unit time. The definitions and collection rules for each parameter are as follows:

[0146] Current node load: refers to the proportion of core resources currently occupied by the fulfilling node to the total available resources of the node. Core resources include, but are not limited to, CPU computing power, memory space, network bandwidth, and service processing channel resources. The value range is normalized to [0,1]. In this embodiment, the monitoring probe built into the node collects data in real time at a preset period (configurable to 100ms~5s) to ensure the real-time nature of the status data.

[0147] Task queue length: refers to the total number of tasks that have been enqueued but not yet started in the task queue of the fulfillment node. Optionally, the estimated execution time of each task in the queue can be collected synchronously to assess the actual backlog of the queue.

[0148] Processing capacity per unit time: refers to the number of standard tasks that a fulfilling node can complete per unit time (per second / per minute), i.e., the node's TPS (transactions per second) or QPS (requests per second). This value is dynamically calibrated based on the node's historical execution data, hardware configuration, and current operating environment, rather than a fixed nominal value.

[0149] In this step, an encrypted communication connection is established with the monitoring and management module of the corresponding fulfillment node through a preset node status communication interface to pull target status data in real time; or the status change message of the corresponding fulfillment node is subscribed to through a distributed configuration center. When the node status change exceeds a preset threshold, the updated status information is automatically obtained to avoid invalid polling and reduce communication overhead.

[0150] S1042. Calculate the node adaptation coefficient of the second subtask based on the node status information.

[0151] Based on the node status information, the node adaptation coefficient of the second subtask is calculated. Specifically, for the j-th second subtask, its estimated execution time t can be considered. j Based on resource consumption, calculate the node adaptation coefficient at the corresponding performance node.

[0152] In a specific embodiment, the process of calculating the node adaptation coefficient may include: constructing the node load coefficient, queue length coefficient, and processing capacity coefficient corresponding to each fulfillment node; calculating the resource occupancy intensity of the second subtask relative to the fulfillment node based on the resource consumption vector and expected execution time of the second subtask; and performing a combined weighted calculation based on the node load coefficient, queue length coefficient, processing capacity coefficient, and resource occupancy intensity to obtain the node adaptation coefficient of the second subtask.

[0153] Specifically, in this embodiment, node load coefficient, queue length coefficient, and processing capacity coefficient are constructed for each fulfillment node. Based on the current operating status of the fulfillment node, the node load, task queue length, and processing capacity per unit time can be quantified, and parameters of different dimensions are converted into comparable coefficient forms through normalization. Specifically, the node load coefficient characterizes the current resource utilization of the node, the queue length coefficient characterizes the task backlog of the node, and the processing capacity coefficient characterizes the node's ability to complete tasks per unit time.

[0154] Furthermore, the total amount of resources required by the second subtask during execution can be compared with the available resources of the fulfillment node, and combined with the expected execution time of the subtask, the degree of resource occupation of the node can be comprehensively evaluated, thereby obtaining the resource occupation intensity used to characterize the resource pressure of the subtask when it is executed at the node.

[0155] The total resources required by the second subtask during execution can be compared with the available resources of the fulfillment node, and combined with the expected execution time of the subtask, to comprehensively evaluate its resource consumption on the node. This yields the resource consumption intensity, which characterizes the resource pressure on the node when the subtask is executed. By pre-setting weights, various coefficients and resource consumption intensity can be comprehensively processed so that fulfillment nodes with high load, large task backlog, or weak processing capacity have relatively low node fit coefficients; while fulfillment nodes with low load and strong processing capacity have relatively high node fit coefficients.

[0156] For example, the calculation can be performed in the following form:

[0157] ;

[0158] in:

[0159] This represents the node adaptation coefficient of the j-th second subtask at the i-th fulfillment node;

[0160] Indicates node load;

[0161] This indicates the queuing pressure at the nodes;

[0162] Indicates the estimated execution time of the subtask;

[0163] γ1, γ2, and γ3 are weighting coefficients.

[0164] The larger the node adaptability coefficient, the more suitable the subtask is to be executed on the corresponding fulfillment node.

[0165] S1043. Adjust the first priority based on the node adaptation coefficient to obtain the second priority;

[0166] The first priority is adjusted based on the node adaptation coefficient to obtain the second priority.

[0167] Specifically, the original priority can be weighted and corrected based on the node adaptation coefficient, for example:

[0168] ;

[0169] in, Indicates the first priority; This indicates the adjusted second priority.

[0170] In this approach, the higher the node adaptation coefficient, the smaller the adjusted second priority value, and the higher the task execution priority. This method can automatically reduce the priority of subtasks on high-load nodes, thereby reducing the concentration of tasks on high-load nodes.

[0171] S1044. Based on the node status information and the execution relationship between the second subtasks, the first dependency matrix is ​​modified to obtain the second dependency matrix;

[0172] Based on the node status information and the execution relationship between the second subtasks, the first dependency matrix is ​​modified to obtain the second dependency matrix. Specifically, multiple adaptation coefficient ranges can be preset, with each range corresponding to a fixed priority adjustment step size.

[0173] In a specific example, suppose a certain second subtask has a first priority of 10, and consider its node adaptation coefficient on different fulfillment nodes. Depending on the value, the corresponding second priority. The results can be calculated using the formula above. For example, if the node currently has a low load and a short task queue, the calculated node fit coefficient is 0.9, which results in a value of 9 using the formula above. In this case, the priority of the subtask only decreases slightly, but it still has a high scheduling priority and is suitable for priority execution. When the fulfilling node is under medium load: for example, if the node has some task queuing, the corresponding node fit coefficient is 0.6, resulting in a value of 6. When the fulfilling node is under high load: for example, if the node has a long task queue and high processing pressure, the corresponding node fit coefficient is 0.3, resulting in a value of 3.

[0174] These examples demonstrate the node adaptability coefficient. It can map the load status of fulfillment nodes to adjustment factors for the priority of subtasks, so that the scheduling priority of subtasks on different nodes changes dynamically, thereby guiding tasks to be distributed to fulfillment nodes with lower loads, achieving the effect of optimizing resource utilization and reducing node congestion.

[0175] S1045. Associate the second subtask with the corresponding second priority and second dependency matrix to generate the third subtask.

[0176] In this step, updated priority and dependency information can be attached to each second subtask, thereby forming a third subtask containing the following attributes: subtask execution content; second priority; second dependency; and corresponding fulfillment node information. Through this embodiment, the third subtask not only retains the original task structure but also reflects the current system resource status and node load.

[0177] S105. Based on the third subtask, the second dependency matrix, and the second priority, execute the pre-configured reorganization algorithm to generate at least one task processing sequence under the premise of satisfying the second dependency matrix.

[0178] Based on the third subtask, the second dependency matrix, and the second priority, a pre-configured reorganization algorithm is executed to generate at least one task processing sequence, provided that the second dependency matrix is ​​satisfied.

[0179] Specifically, while ensuring that the dependencies between subtasks are not disrupted, the subtasks can be sorted according to their priority, and the task execution order can be adjusted in combination with the processing capacity of the fulfillment nodes, thereby generating one or more candidate task processing sequences.

[0180] When there are multiple executable subtasks, subtasks with higher priority or lower resource consumption can be selected to be added to the task sequence in order to improve overall execution efficiency.

[0181] See Figure 4 In one specific embodiment, one way to generate a task processing sequence may include:

[0182] S1051. The third subtask is initially sorted according to the second priority to obtain an initial task sequence;

[0183] The third subtasks are initially sorted according to the second priority to obtain an initial task sequence. Specifically, all third subtasks can be sorted from high to low according to the second priority to form a linear initial task sequence. In this initial task sequence, subtasks with higher priority are placed at the beginning to have priority in execution.

[0184] S1052. Dependency constraint judgment is performed on the initial task sequence based on the second dependency matrix;

[0185] In this step, each third subtask can be checked one by one according to the initial task sequence to see if it satisfies the preceding dependencies defined in the second dependency matrix. For example, for a certain third subtask, if its preceding task has not yet appeared in a previous position, it is determined that the current order of the subtask does not satisfy the dependency constraint.

[0186] S1053. When there is a third subtask that does not satisfy the preceding dependency relationship in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraint of the second dependency matrix is ​​satisfied, and a candidate task sequence is obtained.

[0187] In this step, a third subtask that does not satisfy the dependency relationship can be moved backward, or its dependent preceding task can be moved forward, so that the relative positions of all subtasks in the sequence satisfy the dependency constraint. Through iterative adjustments, the candidate task sequence can simultaneously satisfy the priority ranking trend and dependency constraint requirements.

[0188] In a specific embodiment, one way to generate a candidate task sequence may include the following process: constructing a directed acyclic graph (DAG) based on the second dependency matrix, where nodes in the DAG represent the third subtasks and edges represent dependencies between the third subtasks; calculating the in-degree of the DAG and determining the initial target subtask based on the calculation result; determining target subtasks from the initial target subtasks to add to the candidate task sequence based on the second priority, and removing the nodes and outgoing edges corresponding to the target subtasks from the DAG; updating the in-degree information of the remaining nodes in the DAG and re-determining the initial target subtasks, and repeating the target subtask determination, addition, and node removal operations until all the third subtasks are added to the candidate task sequence.

[0189] Specifically, in this embodiment, each third subtask can be abstracted as a node in the directed acyclic graph (DAG), and the task dependencies described in the second dependency matrix can be mapped as directed edges between nodes. The direction of the directed edges indicates the execution order of the tasks; that is, if third subtask A is a predecessor task of third subtask B, then a directed edge from A to B is established in the graph. In this way, a DAG structure describing the dependencies of all third subtasks can be obtained.

[0190] A directed acyclic graph (DAG) is constructed based on the second dependency matrix. Specifically, each third subtask can be abstracted as a node in the DAG, and the task dependencies described in the second dependency matrix are mapped as directed edges between nodes. The direction of the directed edges indicates the execution order of the tasks; that is, if third subtask A is a predecessor task of third subtask B, then a directed edge from A to B is established in the graph. In this way, a DAG structure describing the dependencies of all third subtasks can be obtained.

[0191] Based on the in-degree calculation results, the initial target subtask set is determined. The third subtasks corresponding to all nodes with an in-degree of zero can be used as the initial target subtask set. Based on this, the third subtask with the highest second priority from the initial target subtask set can be selected as the current target subtask and added to the candidate task sequence. The node corresponding to the target subtask and its associated outgoing edges are removed from the directed acyclic graph. This can be done by deleting the node and its directed edges pointing to other nodes, thereby updating the graph structure.

[0192] For successor nodes that have dependencies on the removed node, their in-degree values ​​are reduced accordingly; when the in-degree of some nodes drops to zero, they are added to the new target initial subtask set.

[0193] Repeat the above process of "target subtask selection - node removal - in-degree update" to continuously select the highest priority task from the current initial target subtask set and add it to the candidate task sequence until all third subtasks have been added to the candidate task sequence. Through this specific embodiment, a candidate task sequence that simultaneously considers task priority and dependency relationships can be generated while satisfying the second dependency matrix constraint.

[0194] S1054. Based on the parallel execution index of the third subtask and the node status information of the corresponding fulfillment node, perform parallel scheduling and allocation of the third subtask in the candidate task sequence to generate at least one set of parallel execution subtasks.

[0195] The system identifies third subtasks in the candidate task sequence that have no direct or indirect dependencies, and, based on the resource status of their corresponding fulfillment nodes, divides these subtasks into task groups that can be executed in parallel. For example, when multiple subtasks have no dependencies and their corresponding nodes have sufficient resources, they can be divided into the same execution batch for parallel processing, thereby improving overall execution efficiency.

[0196] S1055. Reorder the candidate task sequence based on the parallel execution subtasks to generate at least one task processing sequence that satisfies the dependency constraints.

[0197] Groups of subtasks executed in parallel are treated as the same execution phase, and the candidate task sequence is reorganized according to the phase order to generate a task processing sequence containing a hybrid serial and parallel structure. In this task processing sequence, the execution phases satisfy dependency constraints, and subtasks within the same phase can be executed in parallel.

[0198] S106. Calculate the path score for each execution path in the task processing sequence, and determine the target execution path based on the path score.

[0199] Calculate the path score for each execution path in the task processing sequence, and determine the target execution path based on the path score.

[0200] Specifically, each execution path can be comprehensively evaluated based on factors such as the expected execution time of each subtask in the task processing sequence, the load of the fulfillment node, and the task waiting time, to obtain the corresponding path score.

[0201] When there are multiple candidate task processing sequences, the one with the best path score can be selected as the target execution path, and the order processing task can be executed according to the target execution path.

[0202] In a specific embodiment, one implementation of step S106 may include the following process: obtaining execution path information corresponding to each task processing sequence, wherein the execution path information includes the estimated execution time of each subtask, the corresponding fulfillment node, and the task execution order; calculating the total estimated execution time of the execution path and the resource occupancy of each fulfillment node based on the execution path information; calculating the node load balancing index and task waiting time index of the execution path based on the resource occupancy index; comprehensively evaluating the execution path based on the total estimated execution time, node load balancing index, and task waiting time index to obtain a path score; comparing the path scores of each execution path, and determining the target execution path based on the comparison results.

[0203] Specifically, in this embodiment, the execution path information corresponding to each task processing sequence is first obtained. Specifically, for each task processing sequence, its corresponding execution path information can be extracted. This execution path information includes the estimated execution time of each third subtask, the corresponding fulfillment node, and the execution order of the tasks in the sequence, used to describe the scheduling of the task processing sequence during actual execution. The estimated execution times of each subtask in the execution path can be accumulated, and combined with the serial and parallel relationships between tasks, the total estimated execution time of the execution path can be calculated. Simultaneously, based on the resource consumption of each subtask at its corresponding fulfillment node, the resource occupancy of each fulfillment node under this execution path can be statistically analyzed, used to reflect the overall resource occupancy of the path on the system.

[0204] Furthermore, by comparing the differences in resource consumption among different fulfillment nodes, a node load balancing index can be calculated to characterize whether the distribution of tasks among nodes is balanced. At the same time, based on the task execution order and node processing capacity, the queuing waiting time of each subtask during execution can be estimated, thereby obtaining a task waiting time index.

[0205] By weighting the above-mentioned indicators, a path score can be obtained to characterize the overall quality of the execution path. Execution paths with shorter total estimated execution time, more balanced node load distribution, and lower task waiting time have relatively better scores. The path scores of each execution path are compared, and the target execution path is determined based on the comparison results. The execution path with the best score can be selected as the target execution path, and the corresponding task processing sequence can be executed.

[0206] The embodiments of the related devices provided in this application are described in detail below:

[0207] See Figure 5 This application provides an order task splitting and reassembly processing apparatus, comprising:

[0208] The process model construction unit 501 is used to construct an order processing process model based on the order information of the order to be processed, wherein the order processing process model is used to describe the execution relationship between each processing step in the order processing process and to map the processing step to the corresponding fulfillment node;

[0209] The process division unit 502 is used to divide the order processing process into multiple independently executable first subtasks according to the order processing process model, and to calculate a first priority, a first dependency matrix and a resource consumption vector for the first subtasks. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks.

[0210] The task splitting unit 503 is used to obtain resource status information and, based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node.

[0211] The task update unit 504 is used to update the first priority and the first dependency matrix based on the node status information of the second subtask and the corresponding fulfillment node, so as to obtain a third subtask containing the second priority and the second dependency matrix.

[0212] The sequence generation unit 505 is used to execute a pre-configured recombination algorithm based on the third subtask, the second dependency matrix, and the second priority, and generate at least one task processing sequence under the premise of satisfying the second dependency matrix.

[0213] The path generation unit 506 is used to calculate the path score of each execution path in the task processing sequence and determine the target execution path based on the path score.

[0214] Optionally, task update unit 504 is specifically used for:

[0215] Obtain the node status information of the fulfillment node corresponding to the second subtask, wherein the node status information includes at least one of the node's current load, task queue length, and processing capacity per unit time.

[0216] Based on the node status information, calculate the node adaptation coefficient of the second subtask;

[0217] The first priority is adjusted based on the node adaptation coefficient to obtain the second priority;

[0218] Based on the node status information and the execution relationship between the second subtasks, the first dependency matrix is ​​modified to obtain the second dependency matrix;

[0219] The second subtask is associated with the corresponding second priority and second dependency matrix to generate the third subtask.

[0220] Optionally, task update unit 504 is specifically used for:

[0221] Construct the node load coefficient, queue length coefficient, and processing capacity coefficient for each fulfillment node;

[0222] Based on the resource consumption vector and expected execution time of the second subtask, calculate the resource occupancy intensity of the second subtask relative to the fulfillment node;

[0223] Based on the node load coefficient, queue length coefficient, processing capacity coefficient, and resource occupancy intensity, a combined weighted calculation is performed to obtain the node adaptation coefficient of the second subtask.

[0224] Optionally, the sequence generation unit 505 is specifically used for:

[0225] The third subtask is initially sorted according to the second priority to obtain an initial task sequence;

[0226] Dependency constraint judgment is performed on the initial task sequence based on the second dependency matrix;

[0227] When a third subtask does not satisfy the preceding dependencies in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraints of the second dependency matrix are satisfied, thus obtaining a candidate task sequence.

[0228] Based on the parallel execution index of the third subtask and the node status information of the corresponding fulfillment node, the third subtask in the candidate task sequence is scheduled and allocated in parallel to generate at least one set of parallel execution subtasks.

[0229] The candidate task sequence is reordered based on the parallel execution subtasks to generate at least one task processing sequence that satisfies the dependency constraints.

[0230] Optionally, the sequence generation unit 505 is specifically used for:

[0231] A directed acyclic graph is constructed based on the second dependency matrix, where nodes in the directed acyclic graph represent the third subtasks and edges represent the dependencies between the third subtasks.

[0232] The in-degree of the directed acyclic graph is calculated, and the initial subtask of the target is determined based on the calculation result;

[0233] Based on the second priority, target subtasks are determined from the target initial subtasks and added to the candidate task sequence, and the nodes and outgoing edges corresponding to the target subtasks are removed from the directed acyclic graph.

[0234] Update the in-degree information of the remaining nodes in the directed acyclic graph, and redetermine the initial target subtask. Repeat the target subtask determination, addition, and node removal operations until all the third subtasks are added to the candidate task sequence.

[0235] Optionally, task splitting unit 503 is specifically used for:

[0236] Obtain resource status information for each fulfillment node;

[0237] Based on the resource consumption vector of the first subtask, calculate the resource occupancy level of each first subtask on the corresponding fulfillment node, and determine whether the resource occupancy level exceeds the preset resource threshold.

[0238] When the resource occupancy exceeds the preset resource threshold, the corresponding first subtask is divided into multiple subtask units, and the resource occupancy of the subtask unit is lower than the preset resource threshold.

[0239] When multiple first subtasks have dependencies and the sum of their corresponding resource consumption vectors is lower than a preset merging threshold, the multiple first subtasks are merged to generate a merged subtask.

[0240] Based on the subtask unit and the merged subtask, a second subtask is generated that is adapted to the resource capabilities of the fulfillment node.

[0241] Optionally, the path generation unit 506 is specifically used for:

[0242] Obtain the execution path information corresponding to each task processing sequence. The execution path information includes the estimated execution time of each sub-task, the corresponding fulfillment node, and the task execution order.

[0243] Based on the execution path information, calculate the total estimated execution time of the execution path and the resource consumption of each fulfillment node;

[0244] Based on the resource consumption level, calculate the node load balancing index and task waiting time index of the execution path;

[0245] The execution path is comprehensively evaluated based on the total estimated execution time, node load balancing metrics, and task waiting time metrics to obtain a path score;

[0246] The path scores of each execution path are compared, and the target execution path is determined based on the comparison results.

[0247] Optionally, process division unit 502 is specifically used for:

[0248] The order processing flow model is analyzed, and each processing step in the order processing flow is extracted into a basic processing unit;

[0249] Based on the execution relationship between the basic processing units, the basic processing units are divided into multiple independently executable first subtasks;

[0250] Calculate the first priority of each first subtask;

[0251] Based on the execution relationship, construct the dependency relationship between the first subtasks and generate the first dependency matrix;

[0252] Calculate the resource consumption vector for each first subtask, which represents the amount of resources required for the first subtask to be executed at the fulfillment node.

[0253] Please see Figure 6 This application also provides an order task splitting and reorganization processing apparatus, comprising:

[0254] Processor 601, memory 602, input / output unit 603, bus 604;

[0255] The processor 601 is connected to the memory 602, the input / output unit 603, and the bus 604;

[0256] The memory 602 stores a program, and the processor 601 calls the program to execute any of the methods described above.

[0257] This application also relates to a computer-readable storage medium on which a program is stored, which, when run on a computer, causes the computer to perform any of the methods described above.

[0258] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0259] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection between apparatuses or units through some interfaces, and may be electrical, mechanical, or other forms.

[0260] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0261] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0262] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

Claims

1. An order task splitting and reorganizing processing method, characterized in that, include: An order processing flow model is constructed based on the order information of the orders to be processed. The order processing flow model is used to describe the execution relationship between each processing step in the order processing process and to map the processing step to the corresponding fulfillment node. According to the order processing flow model, the order processing flow is divided into multiple independently executable first subtasks, and a first priority, a first dependency matrix, and a resource consumption vector are calculated for each first subtask. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks. Obtain resource status information, and based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node; Based on the node status information of the second subtask and the corresponding fulfillment node, the first priority and the first dependency matrix are updated to obtain a third subtask containing the second priority and the second dependency matrix. Based on the third subtask, the second dependency matrix, and the second priority, a pre-configured reorganization algorithm is executed to generate at least one task processing sequence, provided that the second dependency matrix is ​​satisfied. Calculate the path score for each execution path in the task processing sequence, and determine the target execution path based on the path score; The step of updating the first priority and the first dependency matrix based on the node status information of the second subtask and the corresponding fulfillment node to obtain a third subtask containing the second priority and the second dependency matrix includes: Obtain the node status information of the fulfillment node corresponding to the second subtask, wherein the node status information includes at least one of the node's current load, task queue length, and processing capacity per unit time. Based on the node status information, calculate the node adaptation coefficient of the second subtask; The first priority is adjusted based on the node adaptation coefficient to obtain the second priority; Based on the node status information and the execution relationship between the second subtasks, the first dependency matrix is ​​modified to obtain the second dependency matrix; Associate the second subtask with the corresponding second priority and second dependency matrix to generate the third subtask; The step of calculating the node adaptation coefficient of the second subtask based on the node status information includes: Construct the node load coefficient, queue length coefficient, and processing capacity coefficient for each fulfillment node; Based on the resource consumption vector and expected execution time of the second subtask, calculate the resource occupancy intensity of the second subtask relative to the fulfillment node; Based on the node load coefficient, queue length coefficient, processing capacity coefficient, and resource occupancy intensity, a combined weighted calculation is performed to obtain the node adaptation coefficient of the second subtask.

2. The order task splitting and reorganizing processing method according to claim 1, wherein, Based on the third subtask, the second dependency matrix, and the second priority, a pre-configured reorganization algorithm is executed to generate at least one task processing sequence, provided that the second dependency matrix is ​​satisfied: The third subtask is initially sorted according to the second priority to obtain an initial task sequence; Dependency constraint judgment is performed on the initial task sequence based on the second dependency matrix; When a third subtask does not satisfy the preceding dependencies in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraints of the second dependency matrix are satisfied, thus obtaining a candidate task sequence. Based on the parallel execution index of the third subtask and the node status information of the corresponding fulfillment node, the third subtask in the candidate task sequence is scheduled and allocated in parallel to generate at least one set of parallel execution subtasks. The candidate task sequence is reordered based on the parallel execution subtasks to generate at least one task processing sequence that satisfies the dependency constraints.

3. The order task splitting and reorganizing processing method according to claim 2, wherein, When a third subtask does not satisfy the preceding dependencies in the second dependency matrix, the position of the corresponding third subtask in the initial task sequence is adjusted until the dependency constraints of the second dependency matrix are satisfied, resulting in a candidate task sequence, including: A directed acyclic graph is constructed based on the second dependency matrix, where nodes in the directed acyclic graph represent the third subtasks and edges represent the dependencies between the third subtasks. The in-degree of the directed acyclic graph is calculated, and the initial subtask of the target is determined based on the calculation result; Based on the second priority, target subtasks are determined from the target initial subtasks and added to the candidate task sequence, and the nodes and outgoing edges corresponding to the target subtasks are removed from the directed acyclic graph. Update the in-degree information of the remaining nodes in the directed acyclic graph, and redetermine the initial target subtask. Repeat the target subtask determination, addition, and node removal operations until all the third subtasks are added to the candidate task sequence.

4. The order task splitting and reorganization processing method according to claim 1, characterized in that, The step of obtaining resource status information and, based on the resource status information and the resource consumption vector of the first subtask, executing a pre-configured merging and splitting algorithm to generate a second subtask adapted to the fulfillment node includes: Obtain resource status information for each fulfillment node; Based on the resource consumption vector of the first subtask, calculate the resource occupancy level of each first subtask on the corresponding fulfillment node, and determine whether the resource occupancy level exceeds the preset resource threshold. When the resource occupancy exceeds the preset resource threshold, the corresponding first subtask is divided into multiple subtask units, and the resource occupancy of the subtask unit is lower than the preset resource threshold. When multiple first subtasks have dependencies and the sum of their corresponding resource consumption vectors is lower than a preset merging threshold, the multiple first subtasks are merged to generate a merged subtask. Based on the subtask unit and the merged subtask, a second subtask is generated that is adapted to the resource capabilities of the fulfillment node.

5. The order task splitting and recombining processing method according to claim 1, characterized in that, The step of calculating the path score for each execution path in the task processing sequence and determining the target execution path based on the path score includes: Obtain the execution path information corresponding to each task processing sequence. The execution path information includes the estimated execution time of each sub-task, the corresponding fulfillment node, and the task execution order. Based on the execution path information, calculate the total estimated execution time of the execution path and the resource consumption of each fulfillment node; Based on the resource consumption level, calculate the node load balancing index and task waiting time index of the execution path; The execution path is comprehensively evaluated based on the total estimated execution time, node load balancing metrics, and task waiting time metrics to obtain a path score; The path scores of each execution path are compared, and the target execution path is determined based on the comparison results.

6. The order task splitting and recombining processing method according to claim 1, characterized in that, The step of dividing the order processing flow into multiple independently executable first subtasks according to the order processing flow model, and calculating a first priority, a first dependency matrix, and a resource consumption vector for each first subtask, includes: The order processing flow model is analyzed, and each processing step in the order processing flow is extracted into a basic processing unit; Based on the execution relationship between the basic processing units, the basic processing units are divided into multiple independently executable first subtasks; Calculate the first priority of each first subtask; Based on the execution relationship, construct the dependency relationship between the first subtasks and generate the first dependency matrix; Calculate the resource consumption vector for each first subtask, which represents the amount of resources required for the first subtask to be executed at the fulfillment node.

7. An order task splitting and recombining processing device, characterized in that, The apparatus for performing the method as described in any one of claims 1 to 6 comprises: The process model construction unit is used to construct an order processing process model based on the order information of the order to be processed. The order processing process model is used to describe the execution relationship between each processing step in the order processing process and to map the processing step to the corresponding fulfillment node. The process division unit is used to divide the order processing process into multiple independently executable first subtasks according to the order processing process model, and to calculate a first priority, a first dependency matrix and a resource consumption vector for the first subtasks. The first dependency matrix is ​​used to represent the execution constraint relationship between the first subtasks. The task splitting unit is used to obtain resource status information and, based on the resource status information and the resource consumption vector of the first subtask, execute a pre-configured merging and splitting algorithm to generate a second subtask that is compatible with the fulfillment node. The task update unit is used to update the first priority and the first dependency matrix based on the node status information of the second subtask and the corresponding fulfillment node, so as to obtain a third subtask containing the second priority and the second dependency matrix. The sequence generation unit is used to execute a pre-configured recombination algorithm based on the third subtask, the second dependency matrix, and the second priority, and generate at least one task processing sequence under the premise of satisfying the second dependency matrix. The path generation unit is used to calculate the path score of each execution path in the task processing sequence and determine the target execution path based on the path score.

8. An order task splitting and recombining processing device, characterized in that, The device includes: Processor, memory, input / output units, and bus; The processor is connected to the memory, the input / output unit, and the bus; The memory stores a program, which the processor invokes to perform the method as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium contains a program that, when executed on a computer, performs the method as described in any one of claims 1 to 6.

Images