A data-driven scheduling method for task execution optimization in an intelligent computing center

Abstract

This invention discloses a data-driven scheduling method for task execution optimization in intelligent computing centers, relating to the field of drive scheduling technology. By systematically modeling and reconstructing the task data flow topology, stage coupling relationships, and conflict paths, this invention achieves precise optimized scheduling of data-driven task systems, improving the overall performance of intelligent computing centers in terms of resource utilization, execution efficiency, and scheduling robustness.

Description

Technical Field

[0001] This invention relates to the field of drive scheduling technology, and in particular to a data-driven scheduling method for task execution optimization in an intelligent computing center. Background Technology

[0002] With the rapid growth of computing resources in intelligent computing centers and the concurrent operation of various types of data-intensive tasks, the need for task scheduling optimization in high-performance computing platforms is becoming increasingly prominent. Especially in heterogeneous computing environments and multi-tenant scheduling scenarios, complex data dependencies and resource contention conflicts exist between tasks. Traditional scheduling methods based on resource load or static priority are no longer sufficient to meet the dual goals of efficient operation and maximized resource utilization. In recent years, data-driven scheduling methods have gradually emerged, which dynamically optimize scheduling strategies by collecting runtime data generated during task execution, identifying data flow paths and resource intersections. However, in real-world scenarios, it is necessary not only to handle the temporal dependencies of the tasks themselves but also to address multi-dimensional challenges such as data sharing conflicts between tasks, upstream and downstream transmission delays, and dynamic restructuring of linkage relationships. Therefore, constructing a scheduling method that balances data transmission relationship identification, task cross-conflict management, and scheduling chain restructuring capabilities has become an important direction for current technological evolution.

[0003] CN108897608B discloses a data-driven, scalable, intelligent, general-purpose task scheduling system. By introducing a neural network learning mechanism, it achieves automated design of task scheduling algorithms, improving versatility and adaptability in different application scenarios. This method inputs information such as task running status and resource usage requirements into the neural network for training, generating scheduling policy parameters, which to some extent avoids the limitations of hard-coded rules and manually set scheduling logic. However, this method focuses on training general scheduling rules from the static features of the tasks themselves, failing to effectively identify complex data transfer topologies between tasks. Especially when there are shared data fragments or conflicting codes in the task output stage, it lacks deep modeling of chained task relationships and a dynamic reconstruction mechanism for runtime scheduling order, thus making it difficult to support optimized scheduling of task sets that highly rely on data cross-referencing.

[0004] CN119578850B discloses a method for runtime context parameter passing and dynamic task instance scheduling based on data flow. By constructing a task dependency graph and obtaining the runtime context, it achieves parameter-level transmission control and task instance triggering mechanisms, effectively improving scheduling responsiveness and upstream / downstream linkage efficiency. Although this method has a certain degree of flexibility at the context parameter passing level, it still has two shortcomings: First, the method focuses on the triggering logic at the task instance level and fails to establish identification and unified coding modeling at the data fragment conflict level; second, it lacks structured abstraction and scheduling chain relationship management for task conflicts at data intersections, causing the overall scheduling optimization to remain at the micro level, making it difficult to systematically handle the global optimization problem of scheduling order in high-density data flow intersection environments. Summary of the Invention

[0005] In view of the problems existing in the data-driven scheduling technology, this invention is proposed.

[0006] Therefore, the problem to be solved by this invention is how to divide the internal logic of a task through a three-stage processing structure, and construct a stage vector by combining data interaction features to enhance the semantic expression capability of the task, while providing structural support for subsequent data conflict identification and linkage scheduling.

[0007] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0008] In a first aspect, the present invention provides a data-driven scheduling method for task execution optimization in an intelligent computing center, comprising: extracting the corresponding data processing stage for each task in the set of tasks to be scheduled, and constructing a stage vector; extracting the data transmission path between tasks based on the stage vector set, forming a data cross set between tasks, and generating a conflict-coded tuple for each data segment cross pair; analyzing whether the stage linkage condition is satisfied for task pairs with conflict-coded tuples based on the corresponding stage vector, and if the stage linkage condition is satisfied, defining a chained task relationship and constructing a chain structure set; and reconstructing the task scheduling order based on the set of tasks to be scheduled, the stage vector set, the conflict-coded tuple set, and the chain structure set.

[0009] As a preferred embodiment of the data-driven scheduling method for task execution optimization in the intelligent computing center described in this invention, the construction of the stage vector includes: traversing each task sequentially based on the set of tasks to be scheduled, dividing the task logical structure into a three-segment processing structure; extracting the external data interaction actions involved in each segment of the three-segment processing structure of each task; constructing stage nodes by combining the triggering relationship, processing density, and call frequency information within each segment, with each stage node describing a type of data processing link with data access behavior characteristics; and numbering and combining each stage node according to the task data flow order to generate a stage vector P. iThe sequence strictly follows the data transmission dependency chain within the task.

[0010] As a preferred embodiment of the data-driven scheduling method for task operation optimization in the intelligent computing center described in this invention, the three-stage processing structure includes an input preparation stage, a computation processing stage, and a result submission stage; and the stage nodes in the result submission stage are marked as output stage nodes for determining the data flow relationship between subsequent tasks.

[0011] As a preferred embodiment of the data-driven scheduling method for task execution optimization in the intelligent computing center described in this invention, the formation of the data cross set includes: sequentially reading the stage vector of each task in the set of tasks to be scheduled, and assigning the data fragments accessed by the output stage of each task to the corresponding task's output data structure set, denoted as O. i Simultaneously, the data fragments requested by the input preparation phase of other tasks are incorporated into the input data structure set of the corresponding task, denoted as I. j Construct a structure mapping group to represent the data write-read relationships that may exist between tasks, with elements being (T i ,T j O i ,I j ); where T i and T j Let i and j be the i-th and j-th tasks, respectively. For each pair of tasks in the structure mapping group, extract the intersection of the output data structure set and the input data structure set. If the set of cross segments satisfies the following two conditions, the task pair is considered to have a scheduling-sensitive cross: the number of cross segments exceeds the threshold; at least one cross segment in the set of cross segments is used as the final written content by the previous task and is not marked as a stable segment in the scheduling buffer. For task pairs that satisfy the above joint judgment, they are marked as valid cross relationships, and a ternary structure {T} is generated. i ,T j D ij}; where D ij For task T i Output phase and task T j There are shared or interleaved data segments between the output stages.

[0012] As a preferred embodiment of the data-driven scheduling method for task execution optimization in the intelligent computing center described in this invention, the generation of the conflict-coded tuples includes: extracting task pairs (T) from each pair of valid cross relationships. i ,T j ) and D ij A conflict-coded tuple structure is constructed, which consists of task relationships, cross-data feature summaries, and fragment sensitivity indices; the sensitivity is determined based on the priority between tasks.

[0013] As a preferred embodiment of the data-driven scheduling method for task execution optimization in the intelligent computing center described in this invention, the stage linkage condition includes extracting the corresponding stage vector for each task pair in the conflict-coded tuple set, wherein the stage vector of the preceding task represents the execution stage order, and the stage vector of the following task represents the position of receiving input; if the following two conditions are met simultaneously, a linkage path is considered to exist: the output stage of the preceding task is the final stage, and the internal data has been processed and closed in the corresponding stage; the input stage of the following task is the first stage, and the dependent data exists and has a dominant data label written by the preceding task, and has not been marked as the latest write source by other tasks in the current scheduling cycle; the construction of the chain structure set includes: defining the task pairs that meet the stage linkage condition and do not have other data write sources as chain task relationships, and forming a chain task structure mapping set, where each record represents a directed task pair.

[0014] As a preferred embodiment of the data-driven scheduling method for task execution optimization in the intelligent computing center described in this invention, the task scheduling order reconstruction includes: extracting the stage vector of each pair of tasks, and, based on the linkage direction of the chain structure, reordering the preceding tasks T within the task pair. i Marked as the starting point of the linkage, T j The task pairs are marked as the endpoints of the linkage, forming a chained task linkage queue. For task pairs not included in the chained structure set, they are divided into multiple stage classification groups based on the starting stage attributes of their respective stage vectors. Each stage classification group represents a set of non-chained tasks within the same stage's starting time interval. The tasks within each stage classification group are traversed sequentially. The task insertion order is determined by combining the conflict intensity and sensitivity between tasks in the conflict coded tuple set. Tasks are interleaved to form locally ordered subsequences. Using the chained task linkage queue as the skeleton, locally ordered subsequences are dynamically inserted according to the stage order and conflict relationships to form a complete stage-driven data linkage scheduling sequence. If conflict coded tuples are found in the chained task linkage queue and locally ordered subsequences, the insertion position is adjusted first according to the conflict intensity to ensure the continuity of the chain order and the overall minimization of conflict paths.

[0015] In a second aspect, the present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, wherein: when the computer program instructions are executed by the processor, they implement the steps of the data-driven scheduling method for task operation optimization in the intelligent computing center as described in the first aspect of the present invention.

[0016] Thirdly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein: when the computer program instructions are executed by a processor, they implement the steps of the data-driven scheduling method for task execution optimization in the intelligent computing center as described in the first aspect of the present invention.

[0017] The beneficial effects of this invention are as follows: This invention divides the internal logic of a task into three segments using a three-stage processing structure and constructs a stage vector by combining data interaction features. This not only enhances the semantic expression capability of the task but also provides structural support for subsequent data conflict identification and coordinated scheduling. Compared to existing methods that only trigger scheduling based on task parameters or context states, this invention further utilizes a data fragment-level sharing judgment and conflict encoding mechanism to accurately identify scheduling-sensitive cross-relationships. Based on stage-linkage conditions, it constructs a chain-like task structure, effectively avoiding read-write conflicts and resource contention under multi-task concurrency while achieving sequential constraints within the task chain. Furthermore, by constructing a complete stage-driven data-linkage scheduling sequence and integrating the chain-linkage skeleton with local conflict optimization insertion logic, the rationality of the overall scheduling sequence and the stability of scheduling execution are improved.

[0018] In summary, this invention achieves precise optimization scheduling of data-driven task systems by systematically modeling and reconstructing the task data flow topology, stage coupling relationships, and conflict paths, thereby improving the overall performance of intelligent computing centers in terms of resource utilization, execution efficiency, and scheduling robustness. Attached Figure Description

[0019] To more clearly illustrate the technical solutions of the embodiments of the present invention, 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 the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 This is a flowchart of a data-driven scheduling method used for task execution optimization in an intelligent computing center. Detailed Implementation

[0021] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0022] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0023] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0024] As mentioned in the background section, traditional scheduling methods based on resource load or static priority are no longer sufficient to meet the dual goals of efficient operation and maximized resource utilization. In recent years, data-driven scheduling methods have gradually emerged, which dynamically optimize scheduling strategies by collecting runtime data generated during task execution, identifying data flow paths and resource intersections. However, in real-world scenarios, it is necessary not only to address the temporal dependencies of the tasks themselves, but also to resolve multi-dimensional challenges such as data sharing conflicts between tasks, upstream and downstream transmission delays, and dynamic restructuring of linkage relationships. Therefore, constructing a scheduling method that balances data transmission relationship identification, task cross-conflict management, and scheduling chain restructuring capabilities has become an important direction in current technological evolution.

[0025] Figure 1 This is a flowchart of a data-driven scheduling method for task execution optimization in an intelligent computing center according to an embodiment of the present invention. Figure 1 As shown, the data-driven scheduling method used for task execution optimization in an intelligent computing center includes:

[0026] S1: For each task in the set of tasks to be scheduled, extract the corresponding data processing stage and construct a stage vector.

[0027] In this embodiment of the invention, constructing the stage vector includes the following three steps:

[0028] First, based on the set of tasks to be scheduled, each task is traversed one by one. According to the data reading, calculation and processing and result output operations in the internal data processing process, the task logical structure is divided into a three-stage processing structure: input preparation stage, calculation and processing stage, and result submission stage. The stage nodes in the result submission stage are marked as output stage nodes for the determination of data flow relationships between subsequent tasks.

[0029] It should be noted that in the actual scheduling process of intelligent computing centers, the set of tasks to be scheduled typically contains task entities from multiple heterogeneous sources, and different tasks vary significantly in terms of structural complexity, execution time, and resource call frequency. To improve the efficiency of scheduling in identifying task structures, in this embodiment of the invention, a phased structural analysis is initiated during task initialization, and a structural parsing operation is performed sequentially on each task to be scheduled in the set. This structural parsing operation is not based on task metadata or task description semantics, but rather on the data access logs of the task during its historical execution process as input, combined with the input data fields actually called by the task, the intermediate result buffer fields, and the final submitted output path fields, to construct the operation trajectory of the task execution from a time dimension.

[0030] In the above trajectory, data retrieval calls related to external sources (such as database select statements, remote cache fetching, configuration reading, etc.) are classified as input preparation segments; segments where the task thread generates a large number of internal data write operations, intermediate variable updates, and frequent calculations are classified as computation processing segments; and operations involving writing to external systems, reporting status changes, and logging are classified as result submission segments. This processing segment division method has strong adaptability and can cover computationally intensive, data pipeline, and batch archiving task modes.

[0031] Furthermore, based on the operation type, data source, and processing density characteristics contained in each segment, the logical processing boundaries of the task are marked, and a three-segment data processing segment division scheme is initially formed.

[0032] Specifically, when dividing tasks, relying solely on the physical division based on the task code structure can easily lead to technical bottlenecks such as blurred boundaries and unclear stages. Therefore, this invention models the logical structure based on a runtime data interaction mode. Specifically, before the start of each task execution process, a predefined set of behavior recognition rules is loaded, containing three types of discrimination factors: operation type factor, data source feature factor, and processing density factor.

[0033] Among them, the operation type factor is used to identify the key operation categories that occur in the current stage, such as data retrieval, main loop calculation, multi-threaded concurrent write operations, etc.; the data source characteristic factor is used to identify the type of data source accessed in this stage, such as whether it is local data, whether it involves remote requests, whether it requires cross-node retrieval, etc.; the processing density factor is used to analyze the operation call frequency and memory resource consumption per unit time, which is obtained through statistics from the real-time indicator collection component; after the three types of factors are encoded separately, they are combined to form a logical boundary criterion matrix. This criterion matrix compares the task running trajectory frame by frame and marks the boundary at the feature mutation points, thereby clarifying the start and end points of each processing logic segment.

[0034] Secondly, for each task's three-stage processing structure, the external data interaction actions involved in each stage are extracted, including file reading, database calls, cache synchronization, etc., to form a data channel sequence, which serves as the access feature representation for the corresponding stage. Combining the triggering relationship, processing density, and call frequency information within the stage, stage nodes are constructed, with each stage node describing a type of data processing link with data access behavior characteristics.

[0035] In the specific steps, through embedded data access monitoring, data access operations in each processing segment are captured and labeled in real time during the pre-simulation stage of task execution. Information such as the access objects of database statements, the paths and formats of file I / O operations, and the triggering mechanisms of cache synchronization operations are actively identified and abstracted into standardized data channel structure entries to construct a data channel sequence table.

[0036] Based on this, the present invention combines the triggering relationship of operations during the execution of each segment (such as batch processing triggering, data availability triggering, asynchronous callback triggering, etc.), processing density (such as CPU cycle statistics), and call frequency information (such as the number of requests per unit time) to define the nodes of each segment construction stage.

[0037] A stage node is defined as a logically continuous data processing unit with similar access behaviors in its structure. Each stage node is recorded as an independent entity, and node-level behavioral summary information is added, such as hot data fields, access patterns (sequential / random), trigger dependency fields, etc., ultimately forming a set of stage nodes.

[0038] Finally, the nodes of each stage are numbered and combined according to the order of task data flow to generate a stage vector P. i The sequence strictly follows the data transmission dependency chain within the task; all stage vectors are aggregated into a stage vector set.

[0039] Specifically, this sorting process is not simply based on the execution order, but rather on expanding the graph and numbering operations based on the task data write-read dependency graph. First, a node data relationship graph is constructed, automatically comparing the output data of each node with the input fields of other nodes. If a field correspondence exists, a directed edge is established between the two nodes, and the data dependency fields are recorded. After the graph structure is completed, an acyclic topological sorting algorithm is used to process the nodes, generating a numbered stage sequence. Each stage node is assigned a sequence number, while retaining the predecessor and successor node lists for subsequent scheduling chain structure identification and optimized path reconstruction. After sorting, the stage nodes are combined into a structured stage vector, which contains multiple fields such as stage sequence number, data access summary, inheritance dependencies, and whether it is an output stage, comprehensively representing the task structure.

[0040] S2: Based on the stage vector set, extract the data transmission path between tasks, form the data cross set between tasks, and generate conflict-coded tuples for each data segment cross pair.

[0041] S2.1: In the set of tasks to be scheduled, read the stage vector of each task in sequence, and assign the data fragments accessed by the output stage of each task to the corresponding task's output data structure set, denoted as O. i Simultaneously, the data fragments requested by the input preparation phase of other tasks are incorporated into the input data structure set of the corresponding task, denoted as I. j Construct a structure mapping group to represent the data write-read relationships that may exist between tasks, with elements being (T i ,T j O i ,I j ); where T i and T j Let i be the i-th task and j be the j-th task.

[0042] S2.2: For each task pair in the structure mapping group, extract the intersection of the output data structure set and the input data structure set. To avoid false positives and resource waste, this invention introduces a joint judgment criterion for fine-grained control of the cross segment set. If the cross segment set meets the following two judgment conditions, the task pair is considered to have a scheduling-sensitive cross: the number of cross segments exceeds the number threshold; at least one cross segment in the cross segment set is used as the final written content by the previous task and is not marked as a stable segment in the scheduling buffer. For task pairs that meet the above joint judgment, they are marked as valid cross relationships, and a ternary structure {T} is generated. i ,T j D ij}

[0043] Specifically, for each pair of task number combinations, a judgment is made, and task T is selected respectively. i The corresponding set of output data structures and task T j The corresponding set of input data structures is used to calculate the intersection of the two sets, resulting in a set of data segments that the task pair may share or have write-read interactions. This intersection is called the cross-segment set, which serves as the basic set for conflict identification.

[0044] Among them, stable segments refer to data segments generated during the task output phase that have been registered as not needing to be modified or overwritten again, and whose consistency verification has been completed in the scheduling buffer.

[0045] S2.3: Collision-coded tuple E ij The generation includes: extracting task pairs (T) from each pair of valid cross relationships. i ,T j ) and Dij Construct a conflict-coded tuple structure, where D ij For task T i Output phase and task T j There are shared or interleaved data segments between the output stages.

[0046] The conflict-coded tuple structure consists of task relationships, cross-data feature summaries, and fragment sensitivity indices; the sensitivity is determined based on the priority between tasks. Specifically, task relationships identify the direction of chain dependencies; cross-data feature summaries extract high-frequency fields or path-critical fields from the cross-fragment set; and the fragment sensitivity index is calculated as the ratio of the task scheduling interval to the fragment's effective duration, weighted by combining the task's urgency label in the historical execution sequence, to reflect the fragment's priority in scheduling.

[0047] S3: For task pairs with conflicting coded tuples, analyze whether the stage linkage condition is met based on the corresponding stage vector. If the stage linkage condition is met, define a chained task relationship and construct a chained structure set.

[0048] In this embodiment of the invention, the stage linkage conditions include:

[0049] a. For each task pair in the set of conflict-coded tuples, extract the corresponding stage vector. The stage vector of the preceding task represents the execution stage order. This vector usually contains multiple stage nodes, arranged according to the execution dependency order within the task. The stage vector of the following task represents the position for receiving input, used to determine whether it can accept the written data from the preceding task.

[0050] The stage vector of the previous task is analyzed segment by segment to locate the stage node where the last write action occurs. It is then determined whether this stage node is the final stage of the task, i.e., whether it is at the end of the stage vector. Simultaneously, it is checked whether this stage node has a "processing closure" flag, meaning that the data output by this node has no subsequent consumption in the current task and belongs to the final write content.

[0051] b. If both of the following conditions are met simultaneously, a linkage path is considered to exist: the output stage of the preceding task is the final stage, and the key data involved in this stage has been written and confirmed, the task status is registered as a committable state, and the relevant resource locks and transaction handles have been released, forming a identifiable processing closure state; the input stage of the following task is the first stage, and the dependent data exists that was written by the preceding task and has a dominant data label, and has not been marked as the latest write source by other tasks in the current scheduling cycle.

[0052] Specifically, this invention sequentially determines whether there is an external input data request operation in the first stage node. If the node has read behavior and the access target field has a complete match with the set of cross segments recorded in the conflict-coded tuple, then the stage is determined to be the input start stage; then, the task output segment information registered in the task scheduling buffer is called, and the uniqueness of the input data segment from the previous task is verified, with the verification conditions as above.

[0053] c. The construction of the chain structure set includes: defining task pairs that meet the stage linkage conditions and have no other data writing sources as chain task relationships, and forming a chain task structure mapping set, where each record represents a directed task pair.

[0054] All task pairs are transformed into a chain-like set of elements. A uniqueness check is performed on all preceding task numbers to prevent a single task from being accessed by multiple subsequent tasks, forming a fan-out structure and thus avoiding scheduling conflicts. If a preceding task is found to have multiple subsequent tasks that depend on it, but these subsequent tasks do not share overlapping segments, the task is split into multiple logical task nodes for scheduling mirroring operations, thereby maintaining the purity of the chain-like set. The resulting chain-like set is marked as a strong dependency path by the scheduling engine, giving it priority in subsequent scheduling order reconstruction. The execution order of chain-like task relationships in the task queue is prioritized based on the chain-like set as a constraint boundary, improving data flow stability and the structural stability of system scheduling.

[0055] S4: Based on the set of tasks to be scheduled, the set of stage vectors, the set of conflict-coded tuples, and the set of chain structures, the task scheduling order is reconstructed.

[0056] S4.1: Extract the stage vector for each pair of tasks, and based on the linkage direction of the chain structure, assign the preceding task T within the task pair to the preceding task T. i Marked as the starting point of the linkage, T j Mark it as the endpoint of the linkage to form a chain-like task linkage queue.

[0057] In practice, each task relationship is represented as a unidirectional dependency, meaning the linkage direction is fixed as the preceding task passing data dependencies to the following task. Based on this directionality, the preceding task of each chained task pair is marked as the linkage starting task, and its corresponding following task is marked as the linkage ending task. Based on this, a chained task linkage queue is constructed; that is, multiple task linkage relationships are strung together according to dependency chains with the linkage direction as the axis, forming a scheduling queue with continuity and a unique execution order.

[0058] During the construction process, if multiple chained task pairs share the same starting task as the source node, the linkage order will be determined by the output stage number in the stage vector. The lower the output stage number of the starting task, the earlier it can be referenced by downstream tasks, and it will be placed at the front of the queue. By traversing and constructing multiple chained linkage paths, and performing sequence decomposition on the intersections of the paths, it is ensured that the final linkage queue does not have any loops or path conflicts.

[0059] The chained queue will serve as the skeleton path in the final scheduling sequence, maintaining the closed loop of data transfer between tasks without interruption.

[0060] S4.2: For task pairs not included in the chain structure set, they are divided into multiple stage classification groups based on the starting stage attribute of their respective stage vectors. Each stage classification group represents a set of non-chained tasks in the same stage starting time interval.

[0061] It should be noted that each stage category contains multiple tasks with similar stage numbers or overlapping start time windows, indicating that the tasks in this group have similar data initialization periods. This grouping method ensures comparability and reconstruction efficiency for subsequent insertion sort operations, while also preventing logically parallel or non-overlapping tasks from being mixed into the same sequence.

[0062] For each task's stage vector, the first node is parsed to retrieve the stage number, trigger condition, and external dependency fields. If these fields are highly similar in time or spatial structure, they are grouped into the same stage category. Tasks within each category do not have strong dependencies on each other, providing high scheduling flexibility and allowing for adjustments to execution positions to some extent. When constructing the category group structure, an independent task queue is assigned to each group, and its start time window and schedulable range are registered in the scheduling buffer.

[0063] S4.3: For each stage classification group, traverse the tasks in turn, combine the conflict intensity and sensitivity between tasks in the conflict coding tuple set to determine the task insertion order, and cross-insert the tasks to form a locally ordered subsequence.

[0064] For any two tasks within a classification group, if there is a data write-read crossover relationship between conflicting coded tuple records, the conflict strength and fragment sensitivity are jointly evaluated. Conflict strength is calculated based on crossover frequency and conflict path width. The weighted average of conflict strength and fragment sensitivity serves as a joint factor for ranking priority. Higher conflict strength indicates a greater probability of data write overwriting or cache misalignment during scheduling, while higher sensitivity indicates a shorter data availability window, requiring priority scheduling.

[0065] Based on the above two indicators, priority relationships are established between task pairs, and a directed sorting graph is constructed. Each task in the directed sorting graph is a vertex, and edges represent scheduling priority relationships. A topological sorting algorithm (such as Kahn or DFS, not limited to this specific example) is used to sort the tasks, generating locally ordered subsequences. If priority conflicts exist during the sorting process (i.e., there are simultaneously strong conflicting task pairs with unclear directions), the task with higher sensitivity will be scheduled first by default, and the scheduling cycle of the other task will be postponed to ensure that the scheduling operation has minimal impact on global stability. Finally, all subsequences will be registered and labeled with classification group identifiers.

[0066] S4.4: Using a chained task linkage queue as the framework, locally ordered subsequences are dynamically inserted according to the stage order and conflict relationship to form a complete stage-driven data linkage scheduling sequence; if conflicting encoded tuples are found in the chained task linkage queue and locally ordered subsequences, the insertion position is adjusted according to the conflict intensity to ensure the continuity of the chained order and the overall minimization of conflict paths.

[0067] Specifically, if a task in a local subsequence has a conflict-coded tuple tagging relationship with a chained task, the conflict intensity will be further evaluated: if the conflict intensity is higher than the first intensity threshold, the local task will be delayed and inserted after the next non-conflicting chain node; if the conflict intensity is between the first and second intensity thresholds, it will be determined whether the insertion will disrupt the connectivity of the chain order. If it will not disrupt the connectivity, the insertion will proceed; otherwise, it will be queued for the next scheduling round. Finally, the structure of the scheduling sequence is assembled to form a complete stage-driven data linkage scheduling sequence.

[0068] This embodiment also provides a computer device applicable to a data-driven scheduling method for task optimization in an intelligent computing center, including a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the data-driven scheduling method for task optimization in an intelligent computing center as proposed in the above embodiment.

[0069] The computer device can be a terminal, comprising a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides the environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0070] This embodiment also provides a storage medium on which a computer program is stored. When the program is executed by a processor, it implements the data-driven scheduling method for task operation optimization in the intelligent computing center as proposed in the above embodiments.

[0071] In summary, this invention divides the internal logic of tasks into three stages using a three-stage processing structure and constructs stage vectors based on data interaction features. This not only enhances the semantic expressiveness of tasks but also provides structural support for subsequent data conflict identification and coordinated scheduling. Compared to existing methods that trigger scheduling solely based on task parameters or context states, this invention further utilizes data fragment-level sharing judgment and conflict encoding mechanisms to accurately identify scheduling-sensitive cross-relationships. Furthermore, it constructs a chain-like task structure based on stage-based linkage conditions, effectively avoiding read / write conflicts and resource contention under multi-task concurrency while achieving sequential constraints within the task chain. Moreover, by constructing a complete stage-driven data linkage scheduling sequence and integrating the chain-like linkage framework with local conflict optimization insertion logic, the overall rationality of the scheduling sequence and the stability of scheduling execution are improved.

[0072] In summary, this invention achieves precise optimization scheduling of data-driven task systems by systematically modeling and reconstructing the task data flow topology, stage coupling relationships, and conflict paths, thereby improving the overall performance of intelligent computing centers in terms of resource utilization, execution efficiency, and scheduling robustness.

[0073] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A data-driven scheduling method for task execution optimization in an intelligent computing center, characterized in that: include: For each task in the set of scheduled tasks, extract the corresponding data processing stage and construct a stage vector; Based on the stage vector set, extract the data transmission path between tasks, form the data cross set between tasks, and generate conflict-coded tuples for each data segment cross pair; For task pairs with conflicting coded tuples, analyze whether the stage linkage condition is met based on the corresponding stage vector. If the stage linkage condition is met, define a chained task relationship and construct a chained structure set. Based on the set of tasks to be scheduled, the set of stage vectors, the set of conflict-coded tuples, and the set of chain structures, the task scheduling order is reconstructed. The formation of the data cross set includes: sequentially reading each task from the set of tasks to be scheduled. The stage vector represents the data segments accessed by the output stage of each task and assigns them to the corresponding task's output data structure set, denoted as . Simultaneously, the data fragments requested by the input preparation sections of other tasks are incorporated into the input data structure set of the corresponding task, denoted as... Construct a structure mapping group to represent the data write / read relationships that may exist between tasks, with elements being... ;in, and They are respectively The and the For each task in the structure mapping group, extract the intersection of the output data structure set and the input data structure set. If the set of cross segments meets the following two conditions, the task pair is considered to have a scheduling-sensitive cross: the number of cross segments exceeds the threshold; at least one cross segment in the set of cross segments is used as the final written content by the previous task and is not marked as a stable segment in the scheduling buffer. For task pairs that meet the above joint conditions, they are marked as valid cross relationships, and a ternary structure is generated. ;in, For the task Output phase and task There are shared or interleaved data segments between the output stages; The generation of the conflict-coded tuples includes: extracting task pairs from each pair of valid cross relationships. and A conflict coding tuple structure is constructed, which consists of task relationships, cross-data feature summaries, and fragment sensitivity indices; the sensitivity is determined based on the priority between tasks. The stage linkage conditions include: for each task pair in the conflict-coded tuple set, extracting the corresponding stage vector, where the stage vector of the preceding task represents the execution stage order, and the stage vector of the following task represents the position of receiving input; if the following two conditions are met simultaneously, a linkage path is considered to exist: the output stage of the preceding task is the final stage, and the internal data has been processed and closed in the corresponding stage; the input stage of the following task is the first stage, and the dependent data exists that was written by the preceding task and has a dominant data label, and has not been marked as the latest write source by other tasks in the current scheduling cycle; the construction of the chain structure set includes: defining task pairs that meet the stage linkage conditions and do not have other data write sources as chain task relationships, and forming a chain task structure mapping set, where each record represents a directed task pair.

2. The data-driven scheduling method for task execution optimization in an intelligent computing center as described in claim 1, characterized in that: The construction of the stage vector includes: Based on the set of tasks to be scheduled, each task is traversed one by one, and the logical structure of the task is divided into a three-stage processing structure. For each task's three-stage processing structure, extract the external data interaction actions involved in each stage; By combining the triggering relationships, processing density, and call frequency information within a segment, stage nodes are constructed, and each stage node describes a type of data processing link with data access behavior characteristics. Each stage node is numbered and combined according to the task data flow sequence to generate a stage vector. The sequence strictly follows the data transmission dependency chain within the task.

3. The data-driven scheduling method for task execution optimization in an intelligent computing center as described in claim 2, characterized in that: The three-stage processing structure includes an input preparation stage, a computation processing stage, and a result submission stage; and the stage nodes in the result submission stage are marked as output stage nodes for determining the data flow relationship between subsequent tasks.

4. The data-driven scheduling method for task execution optimization in an intelligent computing center as described in claim 1, characterized in that: The task scheduling order reconstruction includes: Extract the stage vector for each task pair, and based on the linkage direction of the chain structure, identify the preceding tasks within each task pair. Marked as the starting point of the linkage. Mark the endpoint of the linkage to form a chain of linked tasks; For task pairs not included in the chain structure set, they are divided into multiple stage classification groups based on the starting stage attribute of their respective stage vectors. Each stage classification group represents a set of non-chained tasks in the same stage starting time interval. For each stage classification group, the tasks are traversed sequentially. The conflict intensity and sensitivity between tasks in the conflict-coded tuple set are combined to determine the task insertion order. The tasks are interleaved to form a locally ordered subsequence. Using a chain-like task linkage queue as the framework, locally ordered sub-sequences are dynamically inserted according to the stage order and conflict relationship to form a complete stage-driven data linkage scheduling sequence. If conflicting encoded tuples are found in the chained task linkage queue and the locally ordered subsequence, the insertion position is adjusted according to the conflict intensity to ensure the continuity of the chained sequence and the overall minimization of conflict paths.

5. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it implements the steps of the data-driven scheduling method for task execution optimization in the intelligent computing center according to any one of claims 1 to 4.

6. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by the processor, it implements the steps of the data-driven scheduling method for task operation optimization in the intelligent computing center according to any one of claims 1 to 4.

Images