A data flow pipeline task scheduling optimization method with homologous conflict punishment

Abstract

This invention discloses a data pipeline task scheduling optimization method with homogeneous conflict penalties. The data pipeline is constructed as a directed acyclic graph (DAG), and resource overhead and conflict penalties are allocated to nodes and conflict relationships within the graph. Output data target weights are assigned to terminal data nodes in the graph. Based on the DAG, an objective function is constructed to maximize the resource utility of the data pipeline system. An optimal task execution subset search is performed using a heuristic algorithm: under the constraints of the objective function, a hill-climbing algorithm guided by node topology contribution values ​​or a structure-aware simulated annealing algorithm is used to search for the optimal subset of terminal data nodes, resulting in a task scheduling scheme that maximizes resource utility. This invention can efficiently identify near-globally optimal task execution subsets in data pipelines with massive node scales, significantly improving the effective utilization of system computing resources and reducing memory peak usage and system hardware resource competition caused by disordered concurrency.

Description

Technical Field

[0001] This invention relates to the field of data processing systems and system optimization, and in particular to a data pipeline task scheduling optimization method with source conflict penalty. Background Technology

[0002] In modern, complex, large-scale computing systems, massive data processing and feature engineering are core infrastructure supporting complex machine learning (such as pre-training large language models) and underlying business logic. To efficiently handle these pipelines, large computing platforms need to schedule millions of data transformation tasks daily. Modern data pipelines involve deep directed acyclic graphs (DAGs) with complex dependencies, where multiple downstream output tasks typically share intermediate data processing nodes (such as shared underlying cleaning scripts or pre-training corpus fragments) to reduce overall computational and storage overhead.

[0003] Existing literature and research on data pipelines primarily focus on system construction, lineage tracing, debugging, and single-node execution efficiency (Peter Buneman, et al. 2006. Provenance management incurated databases. SIGMOD.) (Yunpeng Chen, et al. 2024. An open dataset of data lineage graphs for data governance research. Visual Informatics.) (RuiLiu, et al. 2023. Optimizing data pipelines for machine learning in featurestores. VLDB.). For example, existing techniques extensively explore how to automatically extract pipeline logic from unstructured environments (Sebastian Eggers. 2024. Automating Data Lineage and Pipeline Extraction. VLDB.) and how to accelerate machine learning workflows through intelligent offloading or elimination of redundancy (Taegeon Um, et al. 2023. Fastflow... VLDB.). However, these traditional scheduling perspectives are mainly limited to static dataset transformation relationships, neglecting how to strategically select a subset of terminal nodes from the perspective of the global system resource pool in ultra-large-scale multi-task concurrent scenarios in order to maximize the overall computing resource utility of the system.

[0004] In practical underlying computing architectures, the combined execution utility of multiple terminal data tasks is not simply a linear sum of their individual utilities. While shared data lineage topology can effectively reduce the overhead of redundant computations, in highly parallel pipelines, simultaneously scheduling downstream task nodes with highly similar origins or overlapping features often triggers "same-origin conflict penalties." For example, in GPU multitasking scenarios, concurrent kernels can experience severe contention on shared caches (cachecontention / cache blocking), becoming a key factor in performance degradation (Chen Zhao, Wu Gao, Feiping Nie, Fei Wang, and Huiyang Zhou. 2020). Fair and Cache Blocking Aware Warp Scheduling for Concurrent Kernel Execution on GPU (Future Generation Computer Systems 112 (2020), 1093–1105). In distributed machine learning clusters, network competition between different tasks can lead to a decrease in training throughput of up to 60% (Xin et al. 2025). vClos: Network Contention Aware Scheduling for Distributed Machine Learning Tasks in Multi-Tenant GPU Clusters (Computer Networks 268 (2025), 111285). Furthermore, highly similar redundant feature sets in the outputs also consume expensive storage resources dramatically, resulting in the overall net resource utility of the system being far lower than the sum of the utilities of each task executing independently. Currently, there is a severe lack of system solutions in the field that can quantitatively model and structurally optimize the conflict losses during parallel scheduling of pipelined tasks.

[0005] In data ecosystems with the aforementioned system scheduling constraints, simply adopting a full-activation scheduling strategy often leads to system computational power collapse or suboptimal utility. In an ideal scenario without considering source conflict penalties, this scheduling optimization task strictly degenerates into a standard maximum weight closure problem, which can be efficiently solved using minimum cut algorithms on flow networks. However, the introduction of the source conflict penalty mechanism adds a quadratic penalty term to the objective function, completely destroying the submodularity required by standard graph cut methods, rendering traditional classical algorithms completely ineffective (William H Cunningham. 1985. On submodular function minimization. Combinatorica.). Theoretically, it can be proven that this maximum weight closure problem with source conflict penalties is not only NP-hard, but obtaining approximate solutions with constant factors is also theoretically extremely difficult.

[0006] For massive data pipelines containing millions of nodes, the computational overhead of exact optimization solvers (Ailsa H Land, et al. 2009. An automatic method for solving discrete programming problems.) is unacceptable in online system scheduling practices due to their enormous topology and the non-approximation of the solution space. Meanwhile, directly applying existing heuristic optimization paradigms to this specific domain also reveals serious flaws: for example, the standard simulated annealing (SA) algorithm (Scott Kirkpatrick, et al. 1983. Optimization by simulatedannealing.) relies on blindly random single-node state flipping, and is prone to getting trapped in local optima when faced with the complex "shared ancestor computational power barrier" and "conflict deadlock" in this problem; the classic quadratic pseudo-Boolean optimization (QPBO) framework used to solve non-submodular problems (Peter L Hammer, Pierre Hansen, and Bruno Simeone. 1984. Roofduality, complementation and persistency in quadratic 0–1 optimization. Mathematical programming 28, 2 (1984), 121–155.) also performs extremely poorly on such highly dense penalty graph structures, with a large number of node variables unable to be effectively determined by the algorithm due to strong non-submodular conflicts. Therefore, there is an urgent need for a novel optimization method that can deeply perceive the topology of directed acyclic graphs and efficiently overcome complex penalty barriers, so as to quickly output the globally optimal scheduling combination of the data pipeline in polynomial time. Summary of the Invention

[0007] The purpose of this invention is to address the shortcomings of existing technologies by providing a data pipeline task scheduling optimization method with homogeneous conflict penalty.

[0008] According to a first aspect of the embodiments of this application, a data pipeline task scheduling optimization method with same-source conflict penalty is provided, including: (1) Construct the data pipeline as a directed acyclic graph, allocate resource overhead and conflict penalty to the nodes in the graph and the conflict relationship between nodes, and assign output data target weights to the terminal data nodes in the graph. (2) Based on the directed acyclic graph and the resource overhead, conflict components and output data target weights in the graph, construct an objective function to maximize the resource utility of the data pipeline system; (3) Search for the optimal task execution subset based on heuristic algorithm: Under the constraint of the objective function, the optimal subset of terminal data nodes is searched by the hill climbing algorithm or the structure-aware simulated annealing algorithm guided by the node topology contribution value, so as to obtain the task scheduling scheme that maximizes resource utility.

[0009] Further, step (1) includes: (1.1) Construct the data pipeline as a directed acyclic graph. middle node set Divided into terminal data node sets Source data nodes and intermediate data node sets The terminal data node is a node with an out-degree of 0, and the edge set is... This represents the dependency logic for data processing; (1.2) For each node in the directed acyclic graph Calculate the cost of all edges pointing to the node, and aggregate it with the node's own storage usage to obtain the individual generation cost of the node. ; (1.3) For intermediate nodes that have independent output requirements, add a zero-overhead virtual leaf node and add it to the terminal data node set. For each terminal data node Assign target weights to output data ; (1.4) For terminal data nodes with feature overlap exceeding a predetermined threshold or concurrent execution conflicts, Assign homogeneous conflict penalty parameters This forms a homogeneous conflict penalty matrix. .

[0010] Further, step (1.4) includes: By calculating the intersection ratio of the input feature sets of two node tasks, or by calculating the cosine similarity of the task data access request vectors, the terminal data node pairs can be obtained. The degree of overlap between features; Nodes are obtained based on the aforementioned feature overlap. For nodes Positive conflict punishment Reverse conflict penalty The sums are used to obtain the terminal data node pair. homogeneous conflict penalty parameters .

[0011] Furthermore, in step (2), the objective function of the system resource utility of the data pipeline... as follows: , in, For the selected terminal data node Target weight sum, For the set of terminal data nodes, To activate the cumulative computational cost of scheduling all ancestor computing nodes, for any selected subset of terminal data nodes... Its ancestor was closed. The minimum set of nodes required to support the scheduling of this subset, including the subset. It computes itself and all its ancestor nodes. The sum of the homogeneous conflict penalties triggered for the selected product portfolio.

[0012] Furthermore, when step (3) employs a hill-climbing algorithm guided by node topology contribution values, it includes the following sub-steps: (3.1a) Calculate each terminal data node Shapley value As its node topology contribution value: , in, For nodes ancestral closure, For node-dependent The set of terminal data nodes, For nodes The target weight, For the node When adding a node to the scheduling queue, nodes that conflict with it Penalties that have already been triggered in the current queue; (3.2a) The node topology contribution value calculated according to step (3.1a) Sort all nodes in descending order, set several percentage thresholds, and select the top-ranked nodes to form different initial candidate subsets. ; (3.3a) For each of the initial candidate subsets Perform local hill-climbing search separately, iteratively switching the containment state of individual nodes and greedily accepting options that can improve system resource efficiency. The changes are made until convergence is obtained to obtain an optimized subset of terminal data nodes; (3.4a) Compare the optimized terminal data node subsets obtained under all proportional thresholds, and take the subset that achieves the maximum system resource utility as the final task scheduling scheme.

[0013] Furthermore, when step (3) employs the structure-aware simulated annealing algorithm, it includes the following sub-steps: (3.1b) Analysis of the homogeneity conflict penalty matrix Extract the set of mutually exclusive conflicting factions Based on the ancestor overlap between nodes in a directed acyclic graph, a collaborative index containing leader and follower nodes is constructed. ; (3.2b) During the dynamic decrease of annealing temperature, a temperature-dependent probabilistic scheduling strategy is used for state transition. In the high-temperature exploration phase, the scheduling collaborative index is activated simultaneously. A leader node and its corresponding subset of follower nodes; during the development phase, the conflict faction set is utilized. Perform intra-faction replacement, randomly suspending or shutting down the node with the highest accumulated penalty or its conflict source, based on the aforementioned collaborative index. Perform heuristic repair, that is, when one of the nodes is activated, prioritize activating the collaborative index. Other nodes in; (3.3b) Use a dynamic reference counting array to track the reference counters of ancestor compute nodes on the static lineage path of a node. When the state of a candidate node is flipped, update The cumulative change in net profit only occurs when the reference counter crosses a boundary from 0 to 1 or from 1 to 0. The system decides whether to accept the transferred node subset state based on the Metropolis criterion until the temperature drops to the set minimum threshold and outputs the optimal subset.

[0014] Further, step (3.1b) includes: Scanning the homogeneous conflict penalty matrix Extract the node groups whose homologous conflict penalties exceed a predetermined threshold, and construct a set of conflict factions. ; Based on the directed acyclic graph, the ancestor overlap between terminal data nodes is calculated. If the ancestor overlap exceeds a predetermined threshold, the two are mapped to a follower-leader relationship, where the follower is the node with the shallower topological sort and the leader is the node with the deeper topological sort.

[0015] According to a second aspect of the embodiments of this application, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the method described in the first aspect.

[0016] According to a third aspect of the embodiments of this application, an electronic device is provided, comprising: One or more processors; Memory, used to store one or more programs; When the one or more programs are executed by the one or more processors, the one or more processors perform the method as described in the first aspect.

[0017] According to a fourth aspect of the embodiments of this application, a computer-readable storage medium is provided that stores computer instructions thereon, which, when executed by a processor, implement the steps of the method as described in the first aspect.

[0018] The technical solution of this invention can be summarized as follows: 1. A mathematical model for optimizing task scheduling in a data pipeline with a source conflict penalty is proposed. By constructing a directed acyclic graph and mapping complex system execution constraint attributes (including computational overhead, objective weight, and source conflict penalty), a global objective function that accurately measures the overall resource utility of the system is established. 2. A hill-climbing algorithm (SGHC) guided by node topology contribution value (Shapley value) is proposed. Utilizing an innovative closed-form analytical formula, the topology contribution value of each data processing node is accurately calculated in polynomial time. This value serves as an unbiased estimator to generate a high-quality initial scheduling policy seed. Subsequently, the hill-climbing algorithm is used for local optimization, achieving extremely high time efficiency. 3. A Structure-Aware Simulated Annealing (SASA) algorithm is proposed. It abandons the blind random perturbation of traditional simulated annealing, and makes in-depth use of cooperative clusters and conflicting factions in the pipeline structure. By designing temperature-dependent batch co-activation scheduling and conflict mitigation operators, it effectively avoids local optima traps. The technical solutions provided by the embodiments of this application may include the following beneficial effects: As can be seen from the above embodiments, this application mathematically models data pipeline scheduling from the perspective of the underlying system computing architecture, accurately depicting the complex system constraint relationship between "sharing intermediate computing nodes to reduce redundant computing overhead" and "highly concurrent tasks causing storage redundancy and feature conflict penalties" in the modern complex computing ecosystem. By establishing a maximum weight closure problem model with concurrent conflict penalties, this invention fills the technical gap of traditional data processing pipelines that only focus on the local execution efficiency of a single node, while neglecting the optimization of global resource utility for multi-task concurrency. By combining graph topology network feature perception and metaheuristic algorithms, it not only breaks through the bottleneck of existing methods easily getting trapped in local optimum deadlock when dealing with non-submodular function problems, but also effectively solves the dimensionality curse brought about by large-scale node tasks. Furthermore, at the underlying hardware execution level of the computer, it significantly reduces the peak memory usage and system hardware resource competition caused by disordered concurrency.

[0019] Specifically, the SGHC algorithm of this invention achieves extremely low computational complexity by utilizing the characteristic estimation of polynomial time, significantly shortening the computation time and additional overhead of the processor in the task scheduling decision stage, enabling the underlying computing power to be invested in the actual data processing flow more quickly, and effectively improving the overall data throughput and response speed of the system; the SASA algorithm further approaches the global limit of system utility optimization. Its designed batch co-activation scheduling mechanism effectively improves the spatiotemporal locality and data hit rate of the underlying cache under the multi-core architecture within the system, and optimizes the data transmission efficiency of the memory bus; at the same time, its conflict mitigation operator successfully avoids memory squeeze, frequent disk data paging overhead, and excessive competition for memory bandwidth caused by highly concurrent tasks from the same source.

[0020] Furthermore, by leveraging the incremental evaluation engine, this invention significantly reduces the memory footprint of the scheduling engine during runtime, avoiding the risk of system memory overflow that is easily triggered during concurrent evaluation of massive numbers of nodes. This allows the invention to be robustly extended to large-scale industrial-grade data scheduling systems containing hundreds of thousands or even millions of nodes, demonstrating strong engineering application value and the ability to optimize general-purpose computing architectures at the underlying system level.

[0021] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and do not limit this application. Attached Figure Description

[0022] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0023] Figure 1 This is a flowchart illustrating a data pipeline task scheduling optimization method with source conflict penalty according to an exemplary embodiment.

[0024] Figure 2 This invention provides a typical data pipeline and a schematic diagram of a directed acyclic graph with source conflict penalty obtained after resource utility modeling; wherein, (a) is the physical architecture diagram of the data pipeline, and (b) is the directed acyclic graph model after mapping system execution constraint attributes.

[0025] Figure 3 This is a schematic diagram illustrating the application process of the hill-climbing algorithm guided by node topology contribution value (Shapley value) provided in an embodiment of the present invention; wherein, (a) is the evaluation result of the topology contribution value of each terminal data node, and (b) is the utility-optimal task execution subset generated by searching based on the evaluation result, and in this example, the subset achieves global utility optimization.

[0026] Figure 4The graph shows a comparison of the system resource utility over time between the optimization algorithm provided in this embodiment and the existing benchmark algorithm under different scale task flow instances; where (a) is the running result on a small-scale instance, (b) is the running result on a medium-scale instance, and (c) is the running result on a large-scale instance.

[0027] Figure 5 This is a block diagram illustrating a data pipeline task scheduling optimization apparatus with source conflict penalty according to an exemplary embodiment.

[0028] Figure 6 This is a schematic diagram of an electronic device according to an exemplary embodiment. Detailed Implementation

[0029] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application.

[0030] The terminology used in this application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. The singular forms “a,” “the,” and “the” used in this application and the appended claims are also intended to include the plural forms unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used herein refers to and includes any or all possible combinations of one or more of the associated listed items.

[0031] It should be understood that although the terms first, second, third, etc., may be used in this application to describe various information, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, without departing from the scope of this application, first information may also be referred to as second information, and similarly, second information may also be referred to as first information. Depending on the context, the word "if" as used herein may be interpreted as "when," "when," or "in response to determination."

[0032] This invention proposes a data pipeline task scheduling optimization method with source conflict penalty. This method rigorously models the complex data processing dependencies and system execution constraints in the data pipeline using mathematical models. By integrating a node topology contribution evaluation mechanism with a graph topology-aware metaheuristic algorithm, it efficiently finds task execution combinations that maximize the overall computational resource utility of the system within a vast solution space.

[0033] Specifically, the method provided by this invention includes the following steps: (1) Data pipeline graph construction and resource overhead mapping: The data pipeline is constructed as a directed acyclic graph, and resource overhead and conflict parameters are assigned to the nodes in the graph and the conflict relationships between the nodes; Specifically, this step may include the following sub-steps: (1.1) Construct the data pipeline as a directed acyclic graph. , where the set of nodes Divided into terminal data node sets Source data nodes and intermediate data node sets edge set This represents the dependency logic for data processing; First, the actual data processing and production pipeline are abstracted and constructed as a directed acyclic graph. In this context, a node represents a specific data entity, and a directed edge u→v represents the processing logic that takes data entity u as input and data entity v as output. The node set... They are divided into two categories: terminal data node sets. Nodes with an out-degree of 0 represent the final output calculation result or task; the set of source data nodes and intermediate data nodes. This represents the raw data and the implicit intermediate processing steps that are not directly output. Edge set This represents strict data processing dependency logic. Subsequently, the nodes and relationships in the graph are mapped and specific system execution constraint parameters are assigned.

[0034] (1.2) Node computation cost ( Transformation with edge overhead: For each node in the directed acyclic graph Calculate the cost of all edges pointing to the node, and aggregate it with the node's own storage usage to obtain the individual generation cost of the node. ; In physical pipelines, computational and storage overhead typically originates from data processing edges (i.e., processing logic). To unify the optimization model, this method implements edge-to-node overhead transformation; that is, all edges directly pointing to a specific node are transformed. The input processing edge computing load and the storage usage unique to this node are aggregated and uniformly defined as this node. Individual generation cost .

[0035] (1.3) Output data target weights ( ): For each terminal data node Assign target weights to output data ; Specifically, the target weights are assigned only to the terminal data nodes. The value represents the preset basic utility of the terminal data node to the system minus the local overhead of its final unique processing step (the sum of the overheads of the edges pointing to that node). If some intermediate nodes in the actual scenario also have independent output requirements, this method standardizes them through Virtual Leaf Transformation: that is, a zero-overhead virtual leaf node is added to the intermediate node, and the target weight is transferred to the virtual leaf node, thereby ensuring that all positive utility parameters in the graph structure are exclusively occupied by the set of leaf nodes. .

[0036] (1.4) Homogeneous conflict penalty matrix ( ): For terminal data nodes with feature overlap exceeding a predetermined threshold or concurrent execution conflicts. Assign homogeneous conflict penalty parameters This forms a homogeneous conflict penalty matrix. ; Specifically, in parallel computing architectures, data processing tasks derived from highly similar sources naturally experience resource contention and feature redundancy during execution. Feature overlap can be defined as the percentage of intersection between the input feature sets of two node tasks (e.g., calculating Jaccard similarity), or the cosine similarity of the task data access request vectors. When the feature overlap exceeds a preset system overlap threshold, it is defined as highly overlapping features. When the system simultaneously schedules such specific task pairs, highly overlapping processing demands can lead to mutual system overhead (e.g., concurrent retrieval of the same basic knowledge base by highly similar retrieval tasks can cause I / O read / write lock contention or significant redundancy in stored features). This concurrent conflict penalty is estimable in real-world systems. For example, in a parallel scheduling scenario involving a large-scale batch inference task A and a lightweight online query task B, both share the GPU's L2 cache resources. First, by calculating the Jaccard similarity (62% here) or the cosine similarity (0.75 here) of the input feature sets of the two tasks, it is determined that they exceed the preset overlap threshold, indicating a source conflict. Furthermore, by monitoring historical system load: recording the throughput of A when it executes independently, and the percentage decrease in A's throughput after B is added concurrently, we obtain the positive conflict penalty penalty(A,B) = A's target weight × 15% (A's throughput decay rate); similarly, recording the throughput of B when it executes independently, and the percentage decrease in B's throughput after A is added concurrently, we obtain the negative conflict penalty penalty(B,A) = B's target weight × 60% (B's throughput decay rate). For example, in a scenario containing a read-only retrieval task C and an incremental update task D, both concurrently access the same structured knowledge base. After determining high homogeneity by calculating the Jaccard similarity (85%) of the data partitions accessed by the two entities, and using the average query latency of C executing independently as a baseline, the latency increase of C after D's concurrent addition (30%) was measured, resulting in penalty(C,D) = target weight of C × 30%. Then, using the write throughput of D executing independently as a baseline, the throughput decrease of D after C's concurrent addition (20%) was measured, resulting in penalty(D,C) = target weight of D × 20%. This asymmetry stems from the fact that the blocking effect of exclusive write locks on read operations (C→D direction) is usually stronger than the backpressure effect of shared read locks on write operations (D→C direction). The above examples illustrate that forward and reverse conflict penalties can be quantitatively estimated by combining feature overlap determination with historical performance degradation monitoring, and the two are usually unequal. This method will use nodes... For nodes Positive conflict punishment Reverse conflict penalty Cumulative, defined as paired effective penalties This leads to the construction of a global homogeneity conflict penalty matrix. .

[0037] (2) Construction of the objective function for system resource utility: Based on the directed acyclic graph and the resource overhead, conflict components and output data target weights in the graph, an objective function for maximizing the resource utility of the data pipeline system is constructed; Based on the previously constructed directed acyclic graph with system execution constraints, binary decision variables are defined. , indicating the activation scheduling of nodes ( ) or exclude ( The graph structure's dependency logic requires that activating and scheduling any node must simultaneously schedule all its predecessor ancestor computation nodes. Given an arbitrary selected subset of terminal data nodes... Define its ancestor closure The minimum set of nodes required to support the scheduling of this subset (including the subset) (Itself and all its ancestor computing nodes). Based on this, construct the system resource utility objective function of the data pipeline. as follows: Among them, the first term of the formula The second term represents the sum of the target weights for the selected terminal data nodes. To activate the cumulative computational cost of scheduling all ancestor computing nodes, the third term... The sum of penalties for same-source conflicts triggered by selected terminal data nodes.

[0038] The physical meaning of this objective function is: the total resource utility of the system equals the total objective weight of the selected terminal tasks, minus the cumulative computational cost of deduplication required to support these tasks, and then minus the sum of the penalties for concurrent execution of these tasks. The core objective of optimization is to find a way to maximize the resource utility of the system. Maximize the optimal task execution subset .

[0039] Combination Figure 2 The present invention provides a detailed description of the modern data pipeline and its directed acyclic graph modeling process. Figure 2(a) in the diagram illustrates a typical modern data pipeline architecture and its derived terminal data task system. The pipeline consists of three levels from left to right: data ingestion, intermediate node processing, and terminal task output. (1) Input end (Source Data): Includes raw source data inputs such as statistical data (S1), scientific data (S2), Web data (S3), and media data (S4). (2) Intermediate processing (Intermediate Data Asset): The source data is transformed into a structured knowledge base (P1) and pre-trained corpus fragments (P2) after fusion and cleaning. Subsequently, P1 and P2 are used together to train the base model (P3), and further aligned training is used to generate an aligned model (P4). These nodes constitute the core shared processing nodes of the data pipeline. (3) Output end (Data Products): Based on the above intermediate shared nodes, the pipeline finally packages and outputs a variety of terminal data processing tasks, including knowledge retrieval API (L1), data snapshot (L2), open source weight acquisition (L3), distillation dataset extraction (L4), enterprise-level SaaS service inference (L5), and code assistant query (L6). (4) Conflict: The diagram specifically uses red double-headed arrows to indicate the concurrent execution conflict between "Open Source Weight Acquisition (L3)" and "Enterprise SaaS Service Inference (L5)". This is because both tasks satisfy highly overlapping feature extraction and parameter calling requirements at the underlying execution level. If the system schedules these two tasks concurrently, the highly overlapping computational flow will cause serious redundant overhead and concurrent conflicts, resulting in a loss of overall system execution efficiency.

[0040] Figure 2 (b) illustrates the use of the method of the present invention for... Figure 2 The physical pipeline in (a) is rigorously mathematically modeled to obtain a directed acyclic graph (DAG) with resource utility attributes. (1) Mapping of nodes to overhead / weights: Each entity in the physical pipeline is rigorously mapped to a node in the graph. Among them, P1 to P4 are mapped to intermediate data nodes, and each is accompanied by the aggregated individual generation overhead (e.g., c: -10, c: -200, etc.), which represents the independent computation or storage occupancy that occurs at this node; L1 to L6 are mapped to terminal data nodes, and are accompanied by the target weights assigned by the system (e.g., R: 80, R: 130, etc.). (2) Mapping of dependencies: The data flow and processing dependencies in the pipeline are mapped to directed edges (e.g., P3 points to P4), which strictly restricts the system topology constraint that "to activate downstream nodes, all upstream nodes that must be scheduled must be scheduled first". (3) Quantitative mapping of conflict penalties: Figure 2In (a) of the figure, the qualitative concurrent conflicts are quantitatively mapped to specific penalty values ​​in the same-source conflict penalty matrix. As shown by the red dashed line in the figure, the conflict penalty between L3 and L5 is explicitly quantified as -100. This means that in the subsequent scheduling optimization search, if the task execution subset generated by the algorithm contains both L3 and L5, the total system resource utility will be reduced by an additional utility penalty value of 100 on the original basis.

[0041] This joint modeling of graph theory and computer system scheduling transforms complex trade-offs in computing resource allocation into unified graph computation parameters, laying a solid mathematical foundation for subsequent execution utility maximization search algorithms (such as SGHC and SASA).

[0042] (3) Search for the optimal task execution subset based on heuristic algorithm: Under the constraint of the objective function, the optimal subset of terminal data nodes is searched by the hill climbing algorithm or the structure-aware simulated annealing algorithm guided by the node topology contribution value, so as to obtain the task scheduling scheme that maximizes resource utility. Since the solution involves maximizing a term with a quadratic penalty... This is a non-submodular NP-hard problem. This invention provides two tailored search algorithms: a hill-climbing algorithm guided by node topology contribution values ​​and a structure-aware simulated annealing algorithm, to meet the different needs of different scenarios regarding the emphasis on solution efficiency and accuracy. (3.1) Hill Climbing Algorithm Guided by Node Topology Contribution Value (Shapley Value) (SGHC) This algorithm is suitable for scenarios requiring rapid response and online dynamic scheduling for large-scale data pipelines. Simple heuristic evaluations often impose the full ancestor cost on a single leaf node, leading to severe distortion in feature evaluation. This algorithm incorporates terminal data nodes into the topology contribution network, using the Shapley value as an unbiased estimate of the system utility potential of each computing node, and reasonably allocating the shared ancestor computational cost and homogeneous conflict penalty.

[0043] node Shapley value Originally, it would have required iterating through all possible combinations of task scheduling sequences: This method decomposes it into the superposition of three independent expectations: target weight, penalty, and cost. 1) The marginal contribution of the target weight component is constant. .

[0044] 2) Regarding the same-origin conflict penalty, when the node When adding a node to the scheduling queue, if there is a conflict with it... If it is already in the current queue, a penalty will be triggered. Due to symmetry, it can be known that... Ranked The preceding probability is strictly: Therefore, the expected penalty is .

[0045] 3) Regarding the overhead portion, nodes Ancestor computing node Expenses Only It depends on The set of all leaf nodes Only when the first node is scheduled will it be... To assume. The probability is... .

[0046] Therefore, this algorithm derives a closed-form analytical formula solvable in polynomial time. The formula is as follows: The target weight of the node's output data is taken, then the ancestor computational cost is subtracted by the average cost distributed among the terminal data nodes depending on each ancestor computational node, and finally the symmetric amortized value of the same-source conflict penalty parameter is subtracted. in, For nodes ancestral closure, For node-dependent The set of terminal data nodes.

[0047] In practice, firstly, the dependency count is calculated through two topological traversals (reverse traversal). (forward traversal to amortize costs), in Calculate all leaf nodes (i.e., terminal data nodes) within the given time complexity. Then, the nodes are sorted in descending order. Subsequently, multiple proportional thresholds are set to extract the top-ranked nodes to form different initial scheduling candidate subsets. Perform layered optimization.

[0048] In each optimization layer, starting from the corresponding initial candidate subset, local hill climbing is performed for fine-tuning. During the hill climbing process, the algorithm iteratively traverses all terminal data nodes, attempting to reverse their current selected state (i.e., if a node is currently in the candidate subset, it attempts to temporarily remove it; if it is not in the candidate subset, it attempts to temporarily add it). After each state reversal, the global objective function is evaluated in real time. The algorithm iterates over the changes in resource utility. If a single node's state transition leads to a positive increase in system utility, the change is greedily accepted permanently, and the current subset state is updated. If utility decreases or remains unchanged, the operation is rolled back. This iterative process continues until the state reversal of any single node can no longer improve the overall system utility, at which point the algorithm converges to a high-quality local optimum for that region. Finally, the system compares the utility of the subsets after hill-climbing optimization under all proportional thresholds, and outputs the subset that achieves the maximum system resource utility as the final optimal task execution combination.

[0049] Figure 3 (a) shows the Shapley values ​​for each terminal data node L1 to L6. In this example, the system first performs two topology traversals and, based on the aforementioned closed-form analytical formula, calculates the topology contribution value of all terminal data nodes in polynomial time. Specifically, for each terminal data node, its output data target weight is taken, minus the share of the individual generation cost of each ancestor computation node in its ancestor closure, amortized according to the number of terminal data nodes dependent on that ancestor, and then minus the symmetric amortization value of the penalty parameter among other nodes that have a source conflict with that node. The calculation results are as follows: Figure 3 As shown in (a) of the table, the Shapley values ​​of L1, L2, L3, and L4 are positive, indicating that these nodes have a positive independent marginal contribution to the overall resource utility of the system after comprehensively considering the target weight contribution, the shared ancestor computational overhead, and the conflict penalty. However, the Shapley values ​​of L5 and L6 are negative. The direct reason for the negative Shapley values ​​of L5 and L6 is that, on the one hand, there is a homogeneous conflict penalty of 100 between L3 and L5, and according to the principle of symmetric amortization, L5 bears 50 of the expected penalty loss. On the other hand, both L5 and L6 rely on high-overhead shared ancestor computation nodes such as P3 and P4, resulting in a heavy computational overhead burden after amortization. The combination of these two factors makes it impossible for their respective target weights to cover their comprehensive costs, thus presenting a negative topological contribution value.

[0050] Figure 3 (b) shows the subset of tasks with optimal utility generated directly after node selection using the "all positive threshold" strategy based on the Shapley value evaluation results described above. Specifically, this algorithm is based on... Figure 3Based on the Shapley value sorting results in (a) of the algorithm, the initial screening threshold of "only retaining nodes with positive Shapley values" is set, excluding L5 and L6 from the candidate subset and retaining L1, L2, L3, and L4 to form the initial candidate subset. Subsequently, the algorithm performs a global evaluation of the system resource utility of this subset and finds that in this small-scale instance, the subset obtained directly after threshold truncation is the global optimal solution. As verified by the system resource utility objective function, the utility value of this subset is maximized. In the subsequent hill-climbing search iteration, the algorithm traverses all terminal data nodes one by one and attempts to reverse their current selected state. The addition or removal of any single node cannot further improve the overall system resource utility. Therefore, the algorithm converges directly on this initial candidate subset without any hill-climbing fine-tuning operation.

[0051] (3.2) Structure-Aware Simulated Annealing Algorithm (SASA) This algorithm is suitable for ultra-large-scale data pipelines that aim for the ultimate computational utility ceiling and involve a large number of shared ancestor computing nodes and complex concurrency conflict penalties. Traditional Simulated Annealing (SA) algorithms, due to their blindly random single-node state flipping, are easily trapped in local optima by the "shared ancestor overhead barrier" (negative scheduling utility for a single node but positive cluster co-activation utility) and "conflict deadlock" (high penalties blocking state transition paths). This algorithm guides batch state transitions by deeply mining the graph topology, making it suitable for scenarios that aim for the ultimate resource utility ceiling.

[0052] Firstly, this method employs structural pre-computation: First, it scans the homogeneity conflict penalty matrix. Extract the node groups with high mutual exclusion characteristics to construct a set of conflict factions. In this algorithm, nodes whose penalty for highly overlapping features (i.e., homogeneous conflict penalty) exceeds a predetermined threshold are classified as nodes with high mutual exclusion features. This allows the algorithm to identify in advance mutual exclusion constraint boundaries where only one node can usually be activated to avoid system deadlock. Secondly, based on the ancestor overlap analysis of the directed acyclic graph, nodes sharing high common computational overhead are classified as collaborative indexes. If most of the computational overhead of a terminal data node A is highly overlapping with that of another node B, i.e., the edge overhead of nodes A and B is x and the total overhead of A is y, if the ancestor overlap x / y exceeds a predetermined threshold, then the two are mapped to a relationship between a follower (a node with a shallower topological sort) and a leader (a node with a deeper topological sort), forming a potential bundled execution scheduling combination.

[0053] This method then employs a temperature-dependent adaptive scheduling strategy: 1) During the high-temperature exploration phase, the algorithm triggers the collaborative co-activation scheduling operator with a high probability (based on a preset temperature-dependent probability function), i.e., the scheduling is activated simultaneously. A leader and their associated group of followers. Specifically, the calculation formula is as follows: .in, This represents the current annealing temperature at the k-th iteration. This indicates the highest initial temperature of the system. This is the maximum trigger probability limit set. To ensure the minimum trigger lower bound for operator traversal, This is a smoothing factor used to control the probability decay curve.

[0054] This approach instantly amortizes the high computational overhead of the ancestor layer through batch concurrency, helping the algorithm quickly overcome the overhead loss barrier of single-node scheduling and build the basic utility foundation of the system.

[0055] 2) As the annealing temperature decreases and the development phase begins, the algorithm dynamically increases the trigger weights of conflict mitigation operators based on a preset inverse temperature-dependent probability function. This includes intra-faction substitution (utilizing...). Within the mutual exclusion group, the active scheduling node is switched, and for the node with the highest accumulated penalty, that node or its main source of conflict is randomly suspended and shut down, i.e., it is shut down first. Other nodes in the system) and heuristic repair (for groups of cooperative nodes with high ancestor overlap, when one of them is activated, its cooperative nodes are activated first) are used to finely smooth out local system conflict losses. Specifically, the calculation formula is as follows: That is, the strategy is exactly the opposite of the high-temperature exploration phase strategy in terms of probability.

[0056] Finally, this method employs a fast incremental evaluation engine: to eliminate the huge overhead of repeatedly calculating the global ancestor closure during each state transition, this algorithm introduces a dynamic reference counting array. When the state of a leaf node flips, the algorithm only traverses its static lineage path and updates the ancestor computation nodes along that path. Reference count The increase or decrease of the objective function only occurs when... occur (The node is needed by a downstream task for the first time, increasing overhead) )or (The node is no longer depended on by any downstream tasks, releasing overhead) Triggering only occurs when the boundary of a function is crossed, minimizing the time cost of each evaluation. Finally, according to the Metropolis criterion, if the change in utility... If the change in utility is greater than 0, then the state transition is accepted directly; if the change in utility is less than 0, then the state transition is accepted directly. If the value is less than 0, the less desirable state is accepted with a certain probability, thus escaping the local optimum. This process iterates continuously until the temperature T drops to the minimum threshold, ultimately outputting the task execution combination that achieves the globally optimal system utility.

[0057] The specific embodiments described above illustrate the technical solution and beneficial effects of the present invention in detail. It should be understood that the above description is only the most preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, additions, and equivalent substitutions made within the scope of the principles of the present invention should be included within the protection scope of the present invention.

[0058] Implementation Examples An embodiment of the present invention was implemented on a computer equipped with an Intel Xeon Gold 6246R CPU and 64GB of memory. This embodiment used anonymized large-scale industrial-grade data flow scheduling logs as the test dataset for multiple sets of comparative experiments. In the preprocessing stage, circular dependencies and isolated compute nodes were removed from the original flow logs, and the system pipeline network was reconstructed to conform to the above definition of a directed acyclic graph. The experiments covered three different pipeline topology sizes: small (average approximately 100,000 compute nodes), medium (average approximately 500,000 compute nodes), and large (average approximately 700,000 compute nodes), corresponding to the attached... Figure 4 (a), (b), and (c) are shown in the examples. As a benchmark, this embodiment simultaneously ran integer linear programming (ILP, as a theoretical global optimal utility upper bound reference), traditional simulated annealing (SA), the Greedy algorithm, and scheduling optimization algorithms such as quadratic programming relaxation (QPR) and quadratic pseudo-Boolean optimization (QPBO). All algorithms were run independently multiple times on the same computing platform, and the average utility value was calculated.

[0059] The experimental results are analyzed as follows: (1) Excellent Time-Utility Ratio of the SGHC Algorithm: The hill-climbing algorithm (SGHC) based on Shapley value proposed in this invention exhibits excellent computational response efficiency in scheduling optimization. In a large-scale system pipeline containing 700,000 nodes, the SGHC algorithm can achieve utility convergence in only about 101.1 seconds and achieve an optimal resource utilization rate of up to 90.3%. In contrast, the QPR relaxation algorithm, which achieves a similar result (91.1%), takes as long as 1359.4 seconds to solve the problem, and the traditional SA algorithm takes nearly 1500 seconds with a lower final solution quality. This shows that the closed-form Shapley formula, as an unbiased estimator of system utility, anchors the high-quality initial scheduling search region with extreme precision, making the increase in the algorithm's own time cost much lower than that of traditional solution algorithms. It is very suitable for ultra-large-scale system pipeline scenarios that require real-time computation and high-frequency online scheduling.

[0060] (2) The ultimate performance and robustness of the SASA algorithm: Among all heuristic algorithms, the Structure-Aware Simulated Annealing (SASA) algorithm proposed in this invention achieves the highest system resource utility result. On small-node network sets, it reaches 97.7% of the theoretical optimal utility value of ILP; on large-scale network sets with up to 700,000 computing nodes, it still maintains a high optimal utility rate of 96.2%. Compared with the traditional SA algorithm (whose optimal utility rate has been stagnant at around 86% and cannot converge), SASA, with its collaborative cluster co-activation and conflict faction-aware batch scheduling operations, successfully overcomes the local deadlock caused by deep graph dependence and strong concurrency conflicts, greatly narrowing the gap with the global theoretical optimal solution. It is an ideal algorithm choice for pursuing the ultimate computing power utility.

[0061] In the experiments, while the Greedy backward greedy algorithm had a fast response, its system utility convergence was extremely low (less than 80%) due to the complete lack of a global topological view. While the ILP algorithm could find the absolute theoretical optimum, its single-step solution on large directed acyclic graphs took over 20,000 seconds, making it completely impractical for online engineering scheduling of dynamic systems. The two algorithms provided in this invention perfectly fill the gap in industrial-grade underlying computing architecture applications between "scheduling decision time" and "system utility accuracy."

[0062] Corresponding to the aforementioned embodiments of the data pipeline task scheduling optimization method with same-source conflict penalty, this application also provides embodiments of the data pipeline task scheduling optimization apparatus with same-source conflict penalty.

[0063] Figure 5 This is a block diagram illustrating a data pipeline task scheduling optimization apparatus with homogeneous conflict penalty according to an exemplary embodiment. (Refer to...) Figure 5 The device may include: The graph construction module M1 is used to construct the data pipeline into a directed acyclic graph, allocate resource overhead and conflict penalty for the nodes in the graph and the conflict relationship between the nodes, and assign output data target weights to the terminal data nodes in the graph. The objective function construction module M2 is used to construct an objective function that maximizes the resource utility of the data pipeline system based on the directed acyclic graph and the resource overhead, conflict components and output data target weights in the graph. The optimal subset search module M3 is used for optimal task execution subset search based on heuristic algorithms: under the constraints of the objective function, the optimal subset of terminal data nodes is searched through a hill-climbing algorithm guided by node topology contribution value or a structure-aware simulated annealing algorithm to obtain a task scheduling scheme that maximizes resource utility.

[0064] Regarding the apparatus in the above embodiments, the specific manner in which each module performs its operation has been described in detail in the embodiments related to the method, and will not be elaborated upon here.

[0065] For the device embodiments, since they basically correspond to the method embodiments, the relevant parts can be referred to in the description of the method embodiments. The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and 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 modules can be selected to achieve the purpose of this application according to actual needs. Those skilled in the art can understand and implement this without creative effort.

[0066] Accordingly, this application also provides a computer program product, including a computer program / instruction that, when executed by a processor, implements the data pipeline task scheduling optimization method with homogeneous conflict penalty as described above.

[0067] Accordingly, this application also provides an electronic device, comprising: one or more processors; a memory for storing one or more programs; and, when the one or more programs are executed by the one or more processors, causing the one or more processors to implement the data pipeline task scheduling optimization method with homogeneous conflict penalty as described above. Figure 6 The diagram shown is a hardware structure diagram of any data processing-capable device, where a data pipeline task scheduling optimization device with same-source conflict penalty provided by an embodiment of the present invention is located. Except for... Figure 6In addition to the processor, memory, and network interface shown, any data processing device in the embodiment may also include other hardware depending on the actual function of the data processing device, which will not be described in detail here.

[0068] Accordingly, this application also provides a computer-readable storage medium storing computer instructions that, when executed by a processor, implement the data pipeline task scheduling optimization method with homogeneous conflict penalty as described above. The computer-readable storage medium can be an internal storage unit of any data processing device as described in any of the foregoing embodiments, such as a hard disk or memory. The computer-readable storage medium can also be an external storage device, such as a plug-in hard disk, smart media card (SMC), SD card, flash card, etc., equipped on the device. Furthermore, the computer-readable storage medium can include both internal storage units of any data processing device and external storage devices. The computer-readable storage medium is used to store the computer program and other programs and data required by the data processing device, and can also be used to temporarily store data that has been output or will be output.

[0069] Other embodiments of this application will readily occur to those skilled in the art upon consideration of the specification and practice of the disclosure herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary techniques in the art not disclosed herein.

Claims

1. A data pipeline task scheduling optimization method with homogeneous conflict penalty, characterized in that, include: (1) Construct the data pipeline as a directed acyclic graph, allocate resource overhead and conflict penalty to the nodes in the graph and the conflict relationship between nodes, and assign output data target weights to the terminal data nodes in the graph. (2) Based on the directed acyclic graph and the resource overhead, conflict components and output data target weights in the graph, construct an objective function to maximize the resource utility of the data pipeline system; (3) Search for the optimal task execution subset based on heuristic algorithm: Under the constraint of the objective function, the optimal subset of terminal data nodes is searched by the hill climbing algorithm or the structure-aware simulated annealing algorithm guided by the node topology contribution value, so as to obtain the task scheduling scheme that maximizes resource utility.

2. The method according to claim 1, characterized in that, Step (1) includes: (1.1) Construct the data pipeline as a directed acyclic graph. middle node set Divided into terminal data node sets Source data nodes and intermediate data node sets The terminal data node is a node with an out-degree of 0, and the edge set is... This represents the dependency logic for data processing; (1.2) For each node in the directed acyclic graph Calculate the cost of all edges pointing to the node, and aggregate it with the node's own storage usage to obtain the individual generation cost of the node. ; (1.3) For intermediate nodes that have independent output requirements, add a zero-overhead virtual leaf node and add it to the terminal data node set. For each terminal data node Assign target weights to output data ; (1.4) For terminal data nodes with feature overlap exceeding a predetermined threshold or concurrent execution conflicts, Assign homogeneous conflict penalty parameters This forms a homogeneous conflict penalty matrix. .

3. The method according to claim 2, characterized in that, Step (1.4) includes: By calculating the intersection ratio of the input feature sets of two node tasks, or by calculating the cosine similarity of the task data access request vectors, the terminal data node pairs can be obtained. The degree of overlap between features; Nodes are obtained based on the aforementioned feature overlap. For nodes Positive conflict punishment Reverse conflict penalty The sums are used to obtain the terminal data node pair. homogeneous conflict penalty parameters .

4. The method according to claim 1, characterized in that, In step (2), the objective function of system resource utility for the data pipeline is... as follows: ， in, For the selected terminal data node Target weight sum, For the set of terminal data nodes, To activate the cumulative computational cost of scheduling all ancestor computing nodes, for any selected subset of terminal data nodes... Its ancestor was closed. The minimum set of nodes required to support the scheduling of this subset, including the subset. It computes itself and all its ancestor nodes. The sum of the homogeneous conflict penalties triggered for the selected product portfolio.

5. The method according to claim 1, characterized in that, When step (3) uses a hill-climbing algorithm guided by node topology contribution values, it includes the following sub-steps: (3.1a) Calculate each terminal data node Shapley value As its node topology contribution value: ， in, For nodes ancestral closure, For node-dependent The set of terminal data nodes, For nodes The target weight, For the node When adding a node to the scheduling queue, nodes that conflict with it Penalties that have already been triggered in the current queue; (3.2a) The node topology contribution value calculated according to step (3.1a) Sort all nodes in descending order, set several percentage thresholds, and select the top-ranked nodes to form different initial candidate subsets. ; (3.3a) For each of the initial candidate subsets Perform local hill-climbing search separately, iteratively switching the containment state of individual nodes and greedily accepting options that can improve system resource efficiency. The changes are made until convergence is obtained to obtain an optimized subset of terminal data nodes; (3.4a) Compare the optimized terminal data node subsets obtained under all proportional thresholds, and take the subset that achieves the maximum system resource utility as the final task scheduling scheme.

6. The method according to claim 1, characterized in that, When step (3) uses the structure-aware simulated annealing algorithm, it includes the following sub-steps: (3.1b) Analysis of the homogeneity conflict penalty matrix Extract the set of mutually exclusive conflicting factions Based on the ancestor overlap between nodes in a directed acyclic graph, a collaborative index containing leader and follower nodes is constructed. ; (3.2b) During the dynamic decrease of annealing temperature, a temperature-dependent probabilistic scheduling strategy is used for state transition. In the high-temperature exploration phase, the scheduling collaborative index is activated simultaneously. A leader node and its corresponding subset of follower nodes; during the development phase, the conflict faction set is utilized. Perform intra-faction replacement, randomly suspending or shutting down the node with the highest accumulated penalty or its conflict source, based on the aforementioned collaborative index. Perform heuristic repair, that is, when one of the nodes is activated, prioritize activating the collaborative index. Other nodes in; (3.3b) Use a dynamic reference counting array to track the reference counters of ancestor compute nodes on the static lineage path of a node. When the state of a candidate node is flipped, update The cumulative change in net profit only occurs when the reference counter crosses a boundary from 0 to 1 or from 1 to 0. The system decides whether to accept the transferred node subset state based on the Metropolis criterion until the temperature drops to the set minimum threshold and outputs the optimal subset.

7. The method according to claim 6, characterized in that, Step (3.1b) includes: Scanning the homogeneous conflict penalty matrix Extract the node groups whose homologous conflict penalties exceed a predetermined threshold, and construct a set of conflict factions. ; Based on the directed acyclic graph, the ancestor overlap between terminal data nodes is calculated. If the ancestor overlap exceeds a predetermined threshold, the two are mapped to a follower-leader relationship, where the follower is the node with the shallower topological sort and the leader is the node with the deeper topological sort.

8. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instruction is executed by the processor, it implements the method as described in any one of claims 1-7.

9. An electronic device, characterized in that, include: One or more processors; Memory, used to store one or more programs; When the one or more programs are executed by the one or more processors, the one or more processors implement the method as described in any one of claims 1-7.

10. A computer-readable storage medium storing computer instructions thereon, characterized in that, When executed by the processor, this instruction implements the steps of the method as described in any one of claims 1-7.

Images