Efficient task allocation method and task scheduling system based on interconnection function

Abstract

The invention discloses an efficient task allocation method and a task scheduling system based on an interconnection function, and belongs to the field of computers. The system comprises a task sending end, an interconnection scheduling network, a task receiving end and a task state monitoring and feedback module. Firstly, a task sending end collects tasks for characteristic analysis, a task dependency graph is constructed, and an initial task execution queue is generated; selecting a first task, and obtaining a corresponding distribution terminal and a receiving server through an interconnection scheduling network; and the resource state and the task state vector of the task are updated, the task state is fed back to the interconnection scheduling network through a task state monitoring and feedback module to update each interconnection function, the next task is continuously selected for scheduling distribution, the resource state and the task state vector are repeatedly updated, and the updating is repeatedly executed. On the premise of minimizing the execution time length or resource consumption, a receiving end obtains an allocation matrix of all tasks and maps the allocation matrix to a corresponding receiving queue. According to the invention, flexible and efficient task allocation is realized.

Description

Technical Field

[0001] The present invention belongs to the field of computers, and in particular relates to an efficient task allocation method and a task scheduling system based on interconnection functions. Background Art

[0002] In modern distributed computing, cloud computing, project management and other fields, task allocation is the key to ensuring efficient operation of the system.

[0003] The goal of task allocation is to reasonably allocate tasks to available resources to improve resource utilization and ensure that tasks are executed smoothly according to priorities and dependencies; however, many existing distributed computing and cloud computing platforms use static task scheduling algorithms to allocate tasks, which usually allocate tasks based on preset rules or priority sorting.

[0004] For example, the shortest path algorithm, greedy algorithm, or priority queue algorithm are widely used in task allocation. Although these methods can provide basic task scheduling capabilities, they cannot cope with complex and dynamically changing task environments. Specifically:

[0005] 1. High computational complexity: Traditional task allocation algorithms usually face high computational complexity when allocating tasks on a large scale. Especially when the number of tasks and resources is huge, the algorithm consumes a lot of computation and time, and cannot adapt to dynamically changing task and resource configurations.

[0006] 2. Low efficiency: Existing methods mostly rely on fixed rules or priority rankings, and are unable to flexibly respond to factors such as task load and resource fluctuations. As a result, the system's resource utilization is low, often leading to problems such as uneven task allocation and resource waste.

[0007] 3. Lack of flexibility: Traditional algorithms do not take into account the complex dependencies between tasks and the dynamic changes in resource usage, and therefore cannot automatically adjust task allocation, which often leads to unreasonable task allocation and affects the overall efficiency of the system.

[0008] Another type of existing task allocation technology uses scheduling algorithms based on constrained optimization. These algorithms transform the task allocation problem into a constrained optimization problem and utilize mathematical methods such as linear programming or integer programming to schedule tasks based on factors such as task resource requirements, priorities, and dependencies. These algorithms can provide more precise resource allocation solutions for the system and attempt to improve the efficiency of task allocation by optimizing the objective function. However, they also present the following challenges:

[0009] 1. High computational overhead: Although this method can accurately solve the task allocation problem, its computational overhead is high. Especially when the scale of tasks and resources is large, the linear programming and integer programming solution process may consume a lot of time and computing resources and cannot quickly respond to the dynamically changing task environment.

[0010] 2. Dependence on preset models: This type of algorithm usually needs to rely on preset mathematical models. When the task and resource status change, it needs to be remodeled and optimized, making it difficult to adapt to environmental changes in real time.

[0011] 3. Difficulty in handling complex dependencies: When there are complex dependencies and priorities between tasks, existing technologies have difficulty optimizing multiple constraints simultaneously, which may lead to unreasonable resource allocation and affect system performance.

[0012] In summary, existing task allocation technologies generally have the following problems:

[0013] 1. Unable to dynamically adapt to changes: Most existing algorithms are static, relying on fixed rules or preset models, and cannot be adjusted in real time to cope with dynamic changes in task load, resource status, etc.

[0014] 2. High computational complexity and low efficiency: Many existing task scheduling algorithms have high computational complexity and low efficiency when processing large-scale tasks, and are unable to quickly respond to task changes under high load.

[0015] 3. Resource waste: Due to the dependencies and priority differences between tasks, existing technologies often cannot completely avoid resource conflicts or task waiting when allocating tasks, resulting in underutilized resources and even idle resources.

[0016] Therefore, how to solve the problems of computational complexity, efficiency, resource waste, etc. in existing task allocation methods through more intelligent and efficient algorithms has become a technical problem that needs to be solved urgently. Summary of the Invention

[0017] To meet the needs of task allocation in complex systems such as modern distributed computing and cloud computing, the present invention proposes an efficient task allocation method and task scheduling system based on interconnection functions, which can flexibly and efficiently allocate tasks under various task requirements and resource conditions.

[0018] The efficient task allocation method based on interconnection function has the following specific steps:

[0019] Step 1: For the tasks collected in the current time period, perform feature analysis on each task separately;

[0020] The task set is T={y1,t2,...,t i ,...,tn}, each task features include execution time, resource requirements, priority and dependencies, etc.; the feature matrix of all tasks for:

[0021]

[0022] d i To perform the task t i Time required; R i For task t i The demand for computing resources; i For task t i Priority; D i For task t i The front-end dependency relationship; n is the total number of tasks, and k represents the number of tasks to be scheduled or the number of batches.

[0023] Step 2: Based on the dependencies between tasks in the feature, construct the task dependency graph G(T,E) and generate the initial task execution order queue;

[0024] The task dependency graph G(T,E) has tasks T as nodes and the dependency relationships E between tasks as directed edges.

[0025] Task t i and t j Directed edges between i ,t j )∈E has a dependency relationship, indicating that task t j Need to be in task t i After completion, execute. Each edge (t i ,t j ) assign weight w ij , used to indicate task execution time, priority impact, etc.

[0026] The adjacency matrix A consisting of the weights of all edges in the dependency graph is expressed as follows:

[0027]

[0028] Traverse the graph nodes. In the first round, initially select node a with in-degree 0 and delete all edges connected to node a. Then, in the second round, continue to select the next node with in-degree 0. When there are at least two nodes with in-degree 0, for each node, calculate the sum of the weights of all predecessor edges connected to the node, and select the node with the maximum sum as the node b in the current round. Continue to delete all edges connected to node b and enter the next round of selection until all nodes are selected and the initial task execution order queue is generated.

[0029] Step 3: Select the first task from the initial task execution order queue, and obtain the corresponding allocation terminal and receiving server of the task through the established m-layer interconnection scheduling network; at the same time, update the resource status and task status vector of the task and feed it back to the interconnection scheduling network.

[0030] The interconnection scheduling network consists of m columns of interconnected units. Depending on actual needs, each column is set as an interconnection function or a scheduling switch matrix. Each interconnection function is a global transformation of the matrix and can use switch patterns within the row to implement operations such as task swap, up-broadcast, down-broadcast, blocking, and shuffle.

[0031] The interconnection function F of the jth layer j The calculation formula is:

[0032]

[0033] A set of optional interconnect functions, such as Swap, Shuffle, Reverse, Secure, etc. is the comprehensive scheduling loss function, s is the state vector of each task s=[s1,s2,…,s n ] T , the initial value is 0; R is the resource matrix of all tasks; j = 1, 2,…, m.

[0034] Each interconnection function F j The interconnection scheduling network as a whole is constructed into a function composite sequence:

[0035]

[0036] N 0 ' is the initial value of the characteristic of the current task; N m ' is the final allocation terminal of the current task;

[0037] Step 4: Update the interconnection functions of the interconnection scheduling network and continue to select the second task from the initial task execution order queue. Through the interconnection scheduling network, obtain the corresponding distribution terminal and receiving server of the task; at the same time, update the resource status and task state vector of the task and feed them back to the interconnection scheduling network.

[0038] The formula for updating the interconnection function is:

[0039]

[0040] in, This represents a feedback-driven adaptive update mechanism for the scheduling function, which adjusts the strategy based on the task state. At this point, only s1 in the task's state vector is updated, while the rest remain zero. Similarly, only the first value in the resource matrix R is updated, while the rest remain unchanged.

[0041] Step 5: Continue to update the interconnection function and select the next task in sequence until all tasks are executed. Under the premise of minimizing the execution time or resource consumption, the allocation matrix of all tasks is obtained and mapped to the corresponding receiving queue.

[0042] The distribution terminals of all tasks form a matrix N m , where the i-th row, i.e., the i-th task, is mapped to the receiving queue T i The formula is:

[0043]

[0044] The efficient task scheduling system based on interconnection functions specifically includes: a task sending end, an interconnection scheduling network, a task receiving end, and a task status monitoring and feedback module.

[0045] The task sending end receives the external task request in the current time period, extracts the characteristics of each task, and constructs the initial characteristic matrix; then the initial characteristic matrix is sent to the interconnection scheduling network through the scheduling bus or network connection, and is mapped layer by layer through each column of the interconnection function or the scheduling switch matrix to finally generate the task scheduling result matrix N m , sent to the task receiving end, after parsing, each task is distributed to the corresponding computing node or resource queue for execution according to the task-resource mapping relationship described in the matrix.

[0046] During task execution, the task status monitoring and feedback module collects task execution progress, resource utilization, delay indicators, and fault information in real time, and transmits the feedback data back to the interconnection scheduling network. It dynamically adjusts the interconnection function or scheduling switch matrix in the interconnection scheduling network to achieve resource reallocation or task migration, thereby improving the system's adaptability in the event of task load fluctuations or resource congestion.

[0047] The advantages of the present invention are:

[0048] 1. The present invention provides an efficient task allocation method and task scheduling system based on interconnected functions. By listing each column of the input and output matrix through the interconnected scheduling network, the changes made to the task location and routing at each stage of the scheduling process can be clearly understood.

[0049] 2. The present invention provides an efficient task allocation method and task scheduling system based on interconnected functions, and a feedback adjustment mechanism during task execution, which can effectively cope with system load fluctuations and changes in task requirements, reducing resource waste and task execution delays. BRIEF DESCRIPTION OF THE DRAWINGS

[0050] Figure 1 It is a flow chart of an efficient task allocation method based on interconnection functions of the present invention;

[0051] Figure 2 This is a schematic diagram of an efficient task scheduling system based on interconnection functions of the present invention. DETAILED DESCRIPTION

[0052] The specific implementation method of the present invention is further described in detail below with reference to the accompanying drawings.

[0053] With the continuous growth of computer systems and tasks, traditional task scheduling methods face many challenges. In particular, in highly concurrent environments, how to rationally allocate system resources, reduce task execution delays, and improve resource utilization has become a pressing issue. Traditional task scheduling methods are often based on static rules, making them difficult to adapt to dynamically changing loads and task demands.

[0054] By introducing the concept of interconnection function design, the present invention provides a dynamic task scheduling method that can flexibly adjust the execution order and resource allocation of tasks based on the characteristics, resource requirements, and dependencies of the tasks, thereby optimizing task scheduling, improving overall system performance, and reducing resource waste and execution delays. Specifically, it is an efficient task allocation method and task scheduling system based on interconnection functions, which optimizes task allocation through the following steps: task characteristic analysis, task dependency modeling, interconnection function scheduling, and task execution and feedback adjustment. By combining multiple interconnection functions (such as identity functions, exchange functions, uniform shuffling functions, etc.), tasks can be flexibly and efficiently allocated under various task requirements and resource conditions.

[0055] The efficient task allocation method based on interconnection function, such as Figure 1 The specific steps are as follows:

[0056] Step 1: For the tasks collected in the current time period, perform feature analysis on each task separately;

[0057] The task set is T = {t1, t2, ..., t i ,...,t n}, each task features include execution time, resource requirements, priority and dependencies, etc.; the feature matrix of all tasks

[0058]

[0059] d i For task t i Time required for execution; R i For task t i The demand for computing resources (such as CPU, memory, storage, etc.); i For task t i Priority; D i For task t i The front-end dependency relationship; n is the total number of tasks, and k represents the number of tasks to be scheduled or the number of batches.

[0060] Step 2: Based on the dependencies between tasks in the feature, a task dependency graph is constructed and an initial task execution order queue is generated.

[0061] The task dependency graph G(T,E) has tasks T as nodes and the dependency relationships E between tasks as directed edges.

[0062] Task t i and t j Directed edges between i ,t j )∈E has a dependency relationship, indicating that task t j Need to be in task t i After completion, execute. Each edge (t i ,t j ) assign weight w ij , used to indicate task execution time, priority impact, etc.

[0063] The adjacency matrix A of the dependency graph is expressed as follows:

[0064]

[0065] Traverse the graph nodes. In the first round, initially select node a with in-degree 0 and delete all edges connected to node a. Then, in the second round, continue to select the next node with in-degree 0. When there are at least two nodes with in-degree 0, for each node, calculate the sum of the weights of all predecessor edges connected to the node, and select the node with the maximum sum as the node b in the current round. Continue to delete all edges connected to node b and enter the next round of selection until all nodes are selected and the initial task execution order queue is generated.

[0066] In order to satisfy the task dependency constraint graph G(T,E), the system introduces edge weight w in the topological sorting process ijAs an indicator of the importance of task dependency, when traversing the graph nodes, not only the schedulable tasks with zero in-degree are judged, but also the priority is evaluated by comprehensively considering the sum of the weights of their predecessor edges, giving priority to scheduling critical tasks with high dependency weights and a great impact on subsequent tasks.

[0067] Step 3: Select the first task from the initial task execution order queue, and obtain the corresponding allocation terminal and receiving server of the task through the established m-layer interconnection scheduling network; at the same time, update the resource status and task status vector of the task and feed it back to the interconnection scheduling network.

[0068] First, select an appropriate scheduling strategy based on task characteristics, resource requirements, and dependencies. This can include adjusting task priorities using a swap function or hierarchical scheduling using a butterfly function.

[0069] The interconnection scheduling network consists of m columns of interconnected units. Depending on actual needs, each column is set as an interconnection function or a scheduling switch matrix. The m-layer interconnection function adjusts the task order or the switch matrix controls the task flow. Task queues are then reordered, priorities adjusted, paths mapped, or resources isolated. Ultimately, while minimizing execution time or resource consumption, the resource allocation of each task is adjusted in real time through monitoring feedback to ensure optimal utilization of system resources.

[0070] Given a set of tasks T = {t1, t2, ..., t n} and its dependency graph G(T,E), where each task has attributes such as priority p(t), resource requirement r(t), etc., forming the initial feature matrix N 0 Input into the interconnection scheduling network, and pass through each layer scheduling N j =F j (N j-1 ) to optimize, and finally output the optimized task allocation matrix N m and receiving queues to ensure that tasks are reasonably scheduled according to priority, load balancing, security isolation and other strategies to achieve efficient execution.

[0071] Each interconnection function is a global transformation of the matrix, and can use switching patterns within rows to implement operations such as swap, up-broadcast, down-broadcast, block, and shuffle to achieve routing or switching between rows.

[0072] The selection of interconnection function is not fixed, but is determined by the dynamic policy scheduling module driven by the system state. This module combines the task state vector s=[s1,s2,…,s n ] T (e.g. average waiting time or failure rate of each task) and resource matrix In each scheduling stage, the interconnection function that best suits the current network load and the target optimization direction is selected. The interconnection function F of the jth layer is j The calculation formula is:

[0073]

[0074] A set of optional interconnect functions, such as Swap, Shuffle, Reverse, Secure, etc. is the comprehensive scheduling loss function, s is the state vector of each task s=[s1,s2,…,s n ] T , the initial value is 0; R is the resource matrix of all tasks; j = 1, 2,…, m.

[0075] Each interconnection function F j The interconnection scheduling network as a whole is constructed into a function composite sequence:

[0076]

[0077] N 0 ' is the initial value of the characteristic of the current task; N m ' is the final allocation terminal of the current task;

[0078] Step 4: Update the interconnection functions of the interconnection scheduling network and continue to select the second task from the initial task execution order queue. Through the interconnection scheduling network, obtain the corresponding distribution terminal and receiving server of the task; at the same time, update the resource status and task state vector of the task and feed them back to the interconnection scheduling network.

[0079] During the task scheduling and execution process, the system introduces a state feedback module to monitor the task running status in real time and return the feedback information to the intermediate scheduling network to achieve dynamic adjustment of the scheduling strategy. Assume that the state vector after task execution is:

[0080]

[0081] Among them, s i Represents the key status indicators of the i-th task queue during execution (such as weighted functions of average latency, resource occupancy, failure rate, etc.).

[0082] The feedback mechanism triggers the dynamic update of some interconnection functions in the interconnection scheduling network according to the changes in the state quantity s and the resource matrix R, satisfying the following feedback scheduling relationship:

[0083]

[0084] in, This represents a feedback-driven adaptive update mechanism for the scheduling function, which adjusts its strategy based on task status. For example, it can enable broadcasting, shuffling, or fault isolation, thereby continuously optimizing the overall task scheduling performance. At this point, only s1 in the task's state vector is updated; the rest remain zero. Similarly, only the first value in the resource matrix R is updated; the rest remain unchanged.

[0085] Step 5: Continue to update the interconnection function and select the next task in sequence until all tasks are executed. Under the premise of minimizing the execution time or resource consumption, the allocation matrix of all tasks is obtained and mapped to the corresponding receiving queue.

[0086] The distribution terminals of all tasks form a matrix N m , where the i-th row, i.e., the i-th task, is mapped to the receiving queue T i The formula is:

[0087]

[0088] Ultimately, all scheduled optimized tasks are distributed to the corresponding receiving nodes or computing resource pools.

[0089] The efficient task scheduling system based on interconnection functions specifically includes: a task sending end, an interconnection scheduling network, a task receiving end, and a task status monitoring and feedback module.

[0090] like Figure 2 As shown in Figure 1, the task sending end receives external task requests for the current time period, extracts features for each task, and constructs an initial feature matrix containing information such as task execution time, resource requirements, priority, and dependencies. The initial feature matrix is then sent to the interconnected scheduling network through a scheduling bus or network connection. After layer-by-layer mapping of each column of interconnection functions or scheduling switch matrices, the task scheduling result matrix N is finally generated. m , sent to the task receiving end, after parsing, each task is distributed to the corresponding computing node or resource queue for execution according to the task-resource mapping relationship described in the matrix.

[0091] During task execution, the task status monitoring and feedback module collects real-time information about task progress, resource utilization, latency metrics, and fault conditions. This feedback data is then transmitted back to the interconnection scheduling network, where it dynamically adjusts the interconnection function or scheduling switch matrix to enable resource reallocation or task migration, thereby improving the system's adaptability to fluctuating task loads or resource congestion. The entire system, with the interconnection function as its core scheduling logic, combines real-time task status awareness with dynamic optimization strategies to ensure efficient, flexible, and robust task scheduling.

[0092] The interconnection scheduling network in the present invention is a function sequence: (F1, F2, ..., F m ), each (F j ) corresponds to the (j)th column in the network and can be one of two types:

[0093] 1. Interconnection functions: such as Swap, Shuffle, Reverse, Secure, etc., which sort, shuffle, reverse the order or securely route the entire column of tasks;

[0094] 2. Switch: Such as "direct connection, exchange, upcast, downcast", etc., uses matrix multiplication to control the mapping or broadcasting of input ports to output ports.

[0095] This forms an intermediate network with multiple columns, where each column performs an interconnection function and completes a scheduling operation.

[0096] For a switch, assume that there are two ports in the same row: the upper port input is (x1) and the lower port input is (x2); these are denoted as vectors [x1, x2].

[0097] The switch can be abstracted as a (2×2) matrix

[0098]

[0099] The output vector is:

[0100] By adjusting the values of ((a,b,c,d)) in the matrix, you can get the effects of direct connection, exchange, uplink or downlink.

[0101] Direct: Outputs data from the input port directly to the specified output port without additional forwarding or copying.

[0102] ·matrix:

[0103] ·calculate:

[0104] Purpose: No scheduling or simple transparent transmission by default, low overhead and fast speed.

[0105] Exchange: Rearrange or swap rows or columns on the same layer, swapping the input and output ends.

[0106] ·matrix:

[0107] ·calculate:

[0108] Purpose: Commonly used to implement horizontal switching. Combined with priority processing in the interconnect function, high-priority tasks can be moved to a less busy or earlier channel.

[0109] Up-Broadcast: Broadcast the tasks received by the current node to the upper level or send them to several specific nodes.

[0110] ·matrix:

[0111] ·calculate:

[0112] Usage: When you need to broadcast high-priority tasks to multiple paths in the upper layer (to ensure that they reach more receivers or key nodes as quickly as possible), you can enable the broadcast mode.

[0113] Down-Broadcast: Multicast or broadcast the tasks received by the current node to the next layer.

[0114] ·matrix:

[0115] ·calculate:

[0116] Purpose: In a multi-tier network, if a receiving queue experiences significant delays or congestion, non-critical tasks can be "downcasted" to a backup tier or broadcast to other idle nodes, alleviating pressure on the blocked end. Furthermore, specific high-priority tasks can be downcasted to multiple alternative nodes to avoid single-node failure or overload.

[0117] Blockade

[0118] If you need to block a port, just set the corresponding output item to 0. For example:

[0119] Output only to the upper port, blocking the lower port:

[0120] Output only to the lower port, blocking the upper port:

[0121] For the interconnection function, the comprehensive scheduling loss function Optimization metrics that may be considered include:

[0122] – System latency;

[0123] – Balanced use of resources;

[0124] – Penalty for high-priority tasks not being scheduled in time;

[0125] – Scheduling risks for safety-sensitive tasks.

[0126] Example conditional trigger mechanism:

[0127] – If Var(R) is high (large fluctuation in resource usage), the uniform shuffling function f is preferred shuffle ;

[0128] –If max(s i ) exceeds the delay threshold θ, the priority scheduling function f is triggered swap ;

[0129] – If the task security levels in the system are densely distributed, the security isolation function f is enabled secure Perform scheduling separation

[0130] This dynamic scheduling mechanism ensures that the scheduling scheme of interconnected functions can be adaptively adjusted according to the real-time operating status of the task system, thereby improving the robustness, response efficiency and scheduling optimization capabilities of the overall system.

[0131] The following are formal definitions and explanations of common interconnect functions:

[0132] Identity

[0133] Notation: f id

[0134] Meaning: The input matrix is directly passed to the output without any change in order or position.

[0135] ·Formalization: If M=[m i,k ] is the output of the previous column, then

[0136] f id (M)[i,k]=m i,k ,

[0137] Where i∈{1,…,n} represents the row index and k represents the column index (the position of the task within the row).

[0138] Application conditions: Applicable to stages where system resources are stable and the current task sequence does not need to be adjusted; can be used as the default scheduling operation under "low load" or "no bottleneck" conditions.

[0139] Swap function

[0140] Notation: f swap

[0141] Meaning: Exchanges or sorts tasks, often used in priority burst scenarios, allowing high-priority tasks to move to earlier or more idle rows / positions.

[0142] Formalization:

[0143] – Suppose there is a priority function p(t), if some task t x , t y Satisfy p(t x )>p(t y ), one or more swap operations can be performed:

[0144]

[0145] – When swapping between rows, you can also swap the tasks in row i and row j. For example:

[0146] f swap (M)[i,k]=M[j,k],f swap (M)[j,k]=M[i,k].

[0147] – The specific switching strategy can be operated according to modes such as “upcast” or “downcast” to move high-priority tasks to the upper or lower rows.

[0148] Application conditions: Enabled when there is a sudden increase in task priority or when certain tasks are latency-sensitive. Suitable for low-latency, high-real-time scenarios.

[0149] Shuffle function

[0150] Notation: f shuffle

[0151] Meaning: Combines all tasks in each row into a single set, randomly breaks them up, and evenly distributes them back to each row. This is often used for load balancing.

[0152] Formalization:

[0153] 1. Let the previous column matrix be M = [m ,k ] n×c (c is the number of columns).

[0154] 2. Merge all tasks into a collection

[0155] 3. Randomly arrange U σ(U)=(u1,u2,…,u |U| ).

[0156] 4. Divide σ(U) equally (or approximately equally) into n rows to form the output matrix M′[i,*].

[0157] Application conditions: Triggered when certain rows or nodes are under long-term high load and resources are uneven, solving local congestion and resource imbalance problems.

[0158] Reverse function

[0159] Notation: f reverse

[0160] Meaning: Reverses the order of rows or tasks within a row. This is often used to address resource shortages or optimize routing, allowing subsequent rows or columns to process tasks that were originally scheduled beforehand.

[0161] Formalization (example: reverse the order of lines):

[0162] f reverse (M)[i,k]=M[n-i+1,k].

[0163] Or reverse the column order:

[0164] f reverse (M)[i,k]=M[i,c-k+1].

[0165] Application conditions: Applicable to scenarios that require late-comers to arrive first or reverse relief of resource shortages, such as short-task priority strategies and preemption mechanisms.

[0166] Butterfly

[0167] Notation: f butterfly

[0168] Meaning: Common in multi-stage networks, used for congestion control or fault bypass. It determines the direction of task flow through bitwise exchange.

[0169] Formalization:

[0170] –Represent the row index i in binary as b1b2…b logn ;

[0171] – Swap some bits at column j, such as b j with b j+1 ;

[0172] –Get the new index i′, let

[0173] f butterfly (M)[i′,k]=M[i,k].

[0174] Application conditions: When path conflicts, network congestion, or link failures occur in a multi-level network, fault-tolerant rerouting or path avoidance is performed.

[0175] Secure routing function (Secure)

[0176] Notation: f secure

[0177] Meaning: Move high-security-level tasks to designated safety rows or safety nodes for isolation, while other tasks remain on their original paths.

[0178] Formalization:

[0179] – Let sec(t) be the safety level of task t;

[0180] – If sec(t) ≥ θ, redirect t to safe row i s ; otherwise unchanged.

[0181] f secure (M)[i s ,k′]=t,f secure (M)[i,k]=Null or replaced,

[0182] Here, k′ may be determined by specific rules (such as putting it at the end of the queue).

[0183] Application conditions: Triggered when the task security level exceeds the threshold; suitable for security isolation, privileged operations, and sensitive data transmission scenarios.

[0184] The present invention is based on an efficient task allocation method of interconnected functions, which is specifically divided into the following four steps:

[0185] 1. Task characteristic analysis: Analyze the execution time, resource requirements, priority and other characteristics of each task to ensure a reasonable basis for subsequent scheduling.

[0186] 2. Task dependency modeling: Based on the dependencies between tasks, a task dependency graph is constructed to provide support for task scheduling and execution order.

[0187] 3. Interconnection function scheduling: Select an appropriate scheduling strategy based on task characteristics, resource requirements, and dependencies (such as using a swap function to adjust task priorities or using a butterfly function for hierarchical scheduling).

[0188] 4. Task execution and feedback adjustment: After the task begins execution, the resource allocation of the task is adjusted in real time through monitoring feedback to ensure optimal utilization of system resources.

[0189] During task execution, the system monitors task status and resource usage in real time and adjusts task scheduling through a feedback mechanism:

[0190] Dynamic resource adjustment: timely adjust computing resource allocation according to task execution status.

[0191] Task execution monitoring: Detect task execution bottlenecks and re-optimize scheduling strategies when necessary.

[0192] Exception handling: When a task fails, roll back or reassign the task.

[0193] Ultimately, the optimization goal of task scheduling is:

[0194]

[0195] Through this optimization solution, the efficiency and stability of task execution are ensured, the utilization of computing resources is improved, and the needs of sudden task scheduling are adapted.

[0196] The present invention provides an efficient task allocation system based on interconnection functions, comprising:

[0197] 1. Sending end (initial task matrix)

[0198] –denoted as M 0 , with n rows (representing n parallel task queues). The number of columns can represent multiple pending tasks or batches in the queue.

[0199] 2. Intermediate network (multiple columns)

[0200] – There are m stages (columns): the jth column uses the interconnection function F j ;

[0201] –The input of the jth column is the output matrix M of the previous column j-1 , the output is matrix M j ;

[0202] – Each “row switch” in the column executes F j logic (such as broadcasting, downloading, swapping, blocking and other specific operations).

[0203] 3. Receiving end (final task matrix)

[0204] –denoted as M m ;

[0205] ·M m The n rows are assigned to n receiving queues {R1,…,R n}, as the final output.

[0206] Example:

[0207] For the sake of example, assume that the initial task matrix n=4, and each row has 4 parallel tasks / batches, which can be expressed as:

[0208]

[0209] Rows 1 to 4 correspond to four parallel queues / ports respectively, and columns 1 to 4 represent several task positions or time batches in the row.

[0210] The following demonstrates how the network executes interconnected functions in columns and obtains the intermediate output M in different scenarios. 1 ,M 2 ,…,M m Each example is accompanied by a schematic diagram or a simplified diagram that visually shows the input / output matrix of each column of the intermediate network.

[0211] Priority burst scenarios:

[0212] Goal: Move high-priority tasks up or to the front of the network.

[0213] · Method: Use f in column 1 swap (Exchange) + row switch "up", subsequent columns can use identity function or small-scale exchange.

[0214] The intermediate network representation:

[0215] 1. Column 0: M 0 (initial).

[0216] 2. Column 1: F1 = f swap Execute priority emergency response; output M 1 .

[0217] 3. Column 2: F2 = f id (identical), output M 2 .

[0218] 4....until the mth column.

[0219] Matrix example:

[0220] 1. Initial M 0 :

[0221]

[0222] 2. Column 1 (F1): Swap

[0223] – Detected Very high priority; swap with row 1 and bring it first.

[0224] – Get M 1 :

[0225]

[0226] 3. Column 2 (F2): Identity

[0227] – No longer changing the order: M 2 =M 1 .

[0228] 4. If there are more columns, they can be represented by M in sequence 3 ,…,M m .

[0229] Finally: The high-priority task enters the front of row 1 and can be processed first in the subsequent process. Load balancing scenario:

[0230] Goal: If a row is heavily loaded, the task needs to be distributed to other rows.

[0231] · Method: Use f in the corresponding column shuffle , output the new M j .

[0232] The intermediate network representation:

[0233] Column 1: Normal transparent transmission (f id ).

[0234] Column 2: Use f shuffle Perform an even shuffle.

[0235] Columns 3, 4, and \dots: You can select other functions or identities as needed.

[0236] Matrix example:

[0237] 1. Initial M 0 Line 3 overload:

[0238]

[0239] 2. Column 1: F1 = f id , output M 1 =M 0 .

[0240] 3. Column 2: F2 = f shuffle

[0241] – Combine all tasks and then randomly break them up and divide them equally;

[0242] – Get M 2 (Example):

[0243]

[0244] Subsequent columns can remain constant or undergo other adjustments; at this time, the pressure on row 3 is significantly relieved.

[0245] Scenarios of resource shortage / high latency blocking:

[0246] Goal: Row 2 is running low on resources. New tasks need to be blocked and existing tasks need to be diverted to other rows.

[0247] Method: Use swap or reverse in the corresponding column, combined with the "block / download" operation; output the new M j The intermediate network representation is:

[0248] Column 1: can be transmitted normally first;

[0249] Column 2: Row 2 is detected to be insufficient, so "block + download" is enabled;

[0250] Column 3: Continue with other strategies, etc.

[0251] Matrix example:

[0252] 1. Initial M 0 Line 2 Resource Exhaustion:

[0253]

[0254] 2. Column 1:

[0255] 3. Column 2: F2 enables "Block Row 2 + Offline", which diverts the tasks in Row 2 to Rows 3 and 4; output M 2 :

[0256]

[0257] Subsequent columns can maintain this diversion state or further fine-tune it.

[0258] Security policy scenarios:

[0259] Goal: Move high-security tasks to safe rows;

[0260] · Method: Use f in a column secure , uniformly detect sec(t) and redirect to safe line.

[0261] The intermediate network representation:

[0262] Column 1: Normal transmission;

[0263] Column 2: f secure , output M 2 ;

[0264] Columns 3, 4…: The subsequent operation depends on the situation.

[0265] Matrix example:

[0266] 1. Initial M 0 :t 1,2 , t 2,3 All with high security level

[0267]

[0268] 2. Column 1:

[0269] 3. Column 2: F2 = f secure

[0270] – If sec(t) ≥ θ, jump to row 1.

[0271] – Get M 2 :

[0272]

[0273] The interconnection functions described in the present invention, such as Swap, Shuffle, Reverse, Butterfly, and Secure, address various scheduling requirements (priority bursts, load balancing, failover, security policies, etc.); they can provide flexible and scalable scheduling solutions in large-scale parallel scenarios, and the combination of each column function is sufficient to cover a variety of sudden and complex application requirements.

[0274] The intermediate network of the present invention can clearly understand the changes made to the task location and routing at each stage of the scheduling process by listing each column of the input and output matrices.

[0275] The feedback adjustment mechanism during task execution described in the present invention can effectively cope with system load fluctuations and changes in task requirements, reducing resource waste and task execution delays.

[0276] In addition to the dynamic task scheduling scheme based on the interconnection function, the present invention can also adopt traditional static task scheduling methods, such as a scheduling system based on a priority queue, or perform task scheduling through fixed rules. Static scheduling methods can usually work effectively when the task load and resource requirements do not change much, but they lack flexibility and adaptability and cannot handle complex and dynamically changing task requirements. The scheduling scheme based on the interconnection function can respond to changes in task characteristics, priorities, dependencies, and resource usage in real time, thereby providing more efficient and flexible scheduling. Although the static method can also meet some basic task scheduling requirements, compared with the scheme based on the interconnection function, it cannot achieve the effect of dynamic adjustment and optimization of resource allocation. Therefore, the dynamic scheduling scheme based on the interconnection function is more suitable for environments with high load, multi-task dependencies, and complex resource scheduling.

[0277] The key technical points of this invention lie in the interconnection function design concept, especially the innovative application of task characteristic analysis, task dependency modeling, interconnection function scheduling, and real-time feedback adjustment during task execution. It can flexibly adjust the execution order of tasks based on task priority, resource requirements, and dependencies, achieving optimal resource allocation and maximizing system performance. The core technical points to be protected include:

[0278] 1. The application of interconnection functions in task scheduling, and how to combine different types of interconnection functions (such as identity function, exchange function, uniform shuffle function, butterfly function) to flexibly schedule tasks according to their characteristics.

[0279] 2. Task dependency modeling and scheduling mechanism: How to build a dynamic scheduling strategy based on the dependencies between tasks and achieve optimal task allocation through interconnection functions.

[0280] 3. Feedback and adjustment mechanism during task execution: How to monitor resource usage in real time during task execution and dynamically adjust task scheduling strategies to ensure efficient task execution.

Claims

1. An efficient task allocation method based on interconnection function, characterized in that: The specific steps are as follows: Step 1: For the tasks collected in the current time period, perform feature analysis on each task separately; Each task’s characteristics include execution time, resource requirements, priority, and dependencies; Step 2: Based on the dependencies between tasks in the feature, construct the task dependency graph G(T,E) and generate the initial task execution order queue; The task dependency graph G(T,E) has tasks T as nodes and dependencies E between tasks as directed edges; Traverse the graph nodes. In the first round, initially select node a with in-degree 0 and delete all edges connected to node a. Then, in the second round, continue to select the next node with in-degree 0. When there are at least two nodes with in-degree 0, for each node, calculate the sum of the weights of all predecessor edges connected to the node, and select the node with the maximum sum as the node b in the current round. Continue to delete all edges connected to node b and enter the next round of selection until all nodes are selected, generating the initial task execution order queue. Step 3: Select the first task from the initial task execution order queue, and obtain the corresponding allocation terminal and receiving server of the task through the established m-layer interconnection scheduling network; at the same time, update the resource status and task state vector of the task and feed it back to the interconnection scheduling network; The interconnection scheduling network consists of m columns of interconnection units. According to actual needs, each column is set as an interconnection function or a scheduling switch matrix; the interconnection function F of the jth layer is j The calculation formula is: is a set of optional interconnection functions; is the comprehensive scheduling loss function, s is the state vector of each task, and its initial value is 0; R is the resource matrix of all tasks; j = 1, 2, ..., m; Each interconnection function F j The interconnection scheduling network as a whole is constructed into a function composite sequence: N 0 ' is the initial value of the characteristic of the current task; N m ' is the final allocation terminal of the current task; Step 4: Update the interconnection functions of the interconnection scheduling network and continue to select the second task from the initial task execution order queue. Through the interconnection scheduling network, obtain the corresponding allocation terminal and receiving server for the task; at the same time, update the resource status and task state vector of the task and feed them back to the interconnection scheduling network; The formula for updating the interconnection function is: in, This indicates a feedback-driven adaptive update mechanism for the scheduling function, which can adjust the strategy based on the task status. In this case, only s1 of the task's state vector is updated, while the rest remain zero. Similarly, only the first value in the resource matrix R is updated, while the rest remain unchanged. Step 5: Continue updating the interconnection function and select the next task in order until all tasks are executed. Under the premise of minimizing execution time or resource consumption, the allocation matrix of all tasks is obtained and mapped to the corresponding receiving queue; The distribution terminals of all tasks form a matrix N m , where the i-th row, i.e., the i-th task, is mapped to the receiving queue T i The formula is:

2. The efficient task allocation method based on interconnection function according to claim 1, characterized in that: In step 1, the task set is T = {t1, t2, ..., t i ,...,t n }, feature matrix for: d i To perform the task t i Time required; R i For task t i The demand for computing resources; i For task t i Priority; D i For task t i The front-end dependency relationship; n is the total number of tasks, and k represents the number of tasks to be scheduled or the number of batches.

3. The efficient task allocation method based on interconnection function according to claim 1, characterized in that: In the step 2, task t i and t j Directed edges between i ,t j )∈E has a dependency relationship, indicating that task t j Need to be in task t i Execute after completion; each edge corresponds to a weight, which is used to represent the task execution time and priority impact; The adjacency matrix A consisting of the weights of all edges in the dependency graph is expressed as follows: w ij For the edge (t i ,t j ) is assigned a weight.

4. The efficient task allocation method based on interconnection function according to claim 1, characterized in that: In step 3, each interconnection function is a global transformation of the matrix, and a switch mode can be used within the row to implement task exchange, upcasting, downcasting, blocking or shuffling operations.

5. An efficient task scheduling system using the efficient task allocation method based on interconnection functions as claimed in claim 1, characterized in that: Specifically include: Task sending end, interconnection scheduling network, task receiving end and task status monitoring and feedback module; The task sending end receives the external task request in the current time period, extracts the characteristics of each task, and constructs the initial characteristic matrix; then the initial characteristic matrix is sent to the interconnection scheduling network through the scheduling bus or network connection, and is mapped layer by layer through each column of the interconnection function or the scheduling switch matrix to finally generate the task scheduling result matrix N m , sent to the task receiving end, and after parsing, each task is distributed to the corresponding computing node or resource queue for execution according to the task-resource mapping relationship described in the matrix.

6. The efficient task scheduling system based on interconnection function according to claim 5, characterized in that: During task execution, the task status monitoring and feedback module collects task execution progress, resource utilization, delay indicators and fault information in real time, and transmits the feedback data back to the interconnection scheduling network, dynamically adjusting the interconnection function or scheduling switch matrix in the interconnection scheduling network to achieve resource reallocation or task migration, thereby improving the system's adaptability in the event of task load fluctuations or resource congestion.

Images