A constraint-aware heterogeneous cluster fair scheduling method and system based on space-time sharing

Abstract

The application discloses a constraint-aware heterogeneous cluster fair scheduling method and system based on space-time sharing. The method comprises the following steps: obtaining a task execution request of a user, and constructing a task constraint matrix; generating a task execution list based on space sharing and maximum minimum fairness; performing constraint-aware fair scheduling among servers, and allocating a target server for a highest priority task; performing round-based time sharing dynamic adjustment until the end of the current round of time; and continuously performing round scheduling until the task execution list is empty. The constraint-aware heterogeneous cluster fair scheduling method based on space-time sharing comprehensively considers task constraints and heterogeneous resource fairness, thereby coordinating and managing distributed computing tasks, ensuring fairness among users, and improving computing efficiency.

Description

Technical Field

[0001] This invention relates to the fields of computer cluster scheduling and high-performance computing, and particularly to a constraint-aware fair scheduling method and system for heterogeneous clusters based on spatiotemporal sharing. Background Technology

[0002] With the rapid development of fields such as artificial intelligence, scientific computing, and big data analytics, the demand for computing power is growing exponentially. Traditional homogeneous computing architectures mainly rely on increasing the frequency and core count of general-purpose central processing units (CPUs). However, limited by power consumption and memory limitations, their performance improvements are gradually approaching physical limits, making it difficult to meet the increasingly complex computing demands of today. Against this backdrop, heterogeneous computing has emerged and has become the mainstream paradigm of modern high-performance computing. The core idea of ​​heterogeneous computing is to integrate two or more processor units with different architectures within a single system, such as general-purpose CPUs, graphics processing units (GPUs) designed for parallel computing, field-programmable gate arrays (FPGAs) dedicated to specific algorithms, and emerging neural network processors. By offloading different computing tasks to the hardware units best suited for them, heterogeneous computing systems can achieve energy efficiency and performance far exceeding that of traditional homogeneous architectures.

[0003] Currently, multi-user heterogeneous clusters have become the mainstream cloud computing infrastructure to support multi-tenant resource sharing and serve massive numbers of users. Rapid hardware iteration has led to the accumulation of multiple generations of processors in clusters, resulting in significant performance differences for the same task on different hardware. Computational tasks in heterogeneous environments have diverse task constraints; when tasks with different characteristics run on these heterogeneous processors, significant performance differentiation occurs due to differences in hardware capabilities. Tasks tend to compete for advanced accelerators, but such resources are insufficient to meet all demands, and their scarcity inevitably leads to competition. Therefore, much research focuses on optimizing efficiency or balancing fairness and efficiency.

[0004] In multi-user shared environments, fairness constraints require each user to guarantee access to computing resources equivalent to an equal distribution of the total cluster resources based on the number of users. In heterogeneous clusters, performance differences between accelerator types and tasks prevent direct resource allocation based on the number of tenants. Existing research typically achieves long-term fairness through time sharing, improving system efficiency under fairness constraints by optimizing the time share of tasks on different accelerators. However, previous studies have shown that cluster computing resource utilization is severely insufficient in multi-user environments. Therefore, time allocation alone is insufficient to directly address the aforementioned multi-dimensional, heterogeneous, and strictly constrained environments, failing to fully utilize computing resources. Thus, an intelligent cluster scheduling method is urgently needed. This method can be task-constrained and dynamically coordinate the balance between fairness and efficiency in heterogeneous resource environments, maximizing overall resource utilization while ensuring multi-user fairness. Summary of the Invention

[0005] To address the aforementioned issues, this invention provides a constraint-aware, heterogeneous cluster fair scheduling method and system based on spatiotemporal sharing. This method is capable of sensing task constraints and improving computational efficiency while ensuring fairness among multiple users in a heterogeneous resource environment.

[0006] This invention provides a constraint-aware fair scheduling method for heterogeneous clusters based on spatiotemporal sharing, comprising the following steps: R1. Obtain the user's task execution request and construct the task constraint matrix; R2. Based on the task constraint matrix, generate a task execution list based on space sharing and maximizing minimum fairness; R3. Obtain the highest priority task from the task execution list, perform constraint-aware fair scheduling among servers, and assign a target server to the highest priority task. R4. Based on the constraint-aware fair scheduling result, perform round-based time sharing dynamic adjustment until the current round ends. If the highest priority task is completed, remove the highest priority task from the task execution list. Repeat steps R2-R4 until the task execution list is empty.

[0007] Preferably, a part of the present invention provides a method for obtaining a user's task execution request and constructing a task constraint matrix, comprising the following steps: Obtain the user's task execution request and retrieve detailed task information; Determine whether the current task execution request is a newly arrived request; If yes, reset the resource acquisition rounds and cluster entry rounds of all tasks to their initial state; otherwise, keep the resource acquisition rounds and cluster entry rounds of all tasks unchanged. Determine whether the current task execution request is a completed request; If yes, reset the resource acquisition rounds and cluster entry rounds of all tasks to their initial state; otherwise, keep the resource acquisition rounds and cluster entry rounds of all tasks unchanged. Construct a task constraint matrix. Based on the detailed task information, create an m×n matrix and set different tasks. different servers Running constraints To constrain Representative task On the server Whether it can run, where m is the number of tasks and n is the number of servers.

[0008] Another part of the present invention provides a method for generating a task execution list based on space sharing and maximizing minimum fairness, comprising the following steps: Obtain the throughput fitting function for different tasks on different servers; Based on the throughput fitting function, calculate the number of shared slots for different servers without considering constraints. Based on the number of shared slots on different servers without considering constraints, calculate the baseline throughput of different tasks on all servers. Based on the throughput fitting function, calculate the actual number of shared slots for different servers under constraints. Based on the actual number of shared slots on different servers under the aforementioned constraints and the maximization of minimum fairness, calculate the actual runtime score of different tasks on different servers. A task execution list is generated based on the actual running time score.

[0009] Another part of the present invention provides a method for generating a task execution list based on space sharing and maximizing minimum fairness, comprising the following steps: Define the resource allocation ratio and throughput fitting function as follows: Where r represents the server resource allocation ratio, , and The fitting parameters of the function representing the change in throughput of task i on the j-th server as a function of resource allocation ratio; Define the additional cost fitting function as: Where r represents the server resource allocation ratio, , and The fitting parameters of the function representing the change of the additional overhead of task i on the j-th server as a function of the resource allocation ratio; Define the throughput fitting function as ; Define the number of shared slots on each server j as the resource allocation ratio. reciprocal ; Calculate the number of shared slots across different servers without considering constraints: using the formula The dynamic programming algorithm is used to calculate the number of shared slots across different servers without considering constraints, where P represents cluster throughput, Maximize represents maximization, m represents the number of tasks, and n represents the number of servers. This represents the number of shared slots in server j. , , This represents the throughput of task i when it runs on server j with the number of shared slots in the space; Calculate the baseline throughput of different tasks across all servers: using the formula Calculate the baseline throughput of different tasks across all servers, where, This represents the baseline throughput of task i across all servers, where m represents the number of tasks and n represents the number of servers. This represents the number of shared slots in server j. This represents the throughput of task i when it runs on server j with the number of shared slots in the space; Calculate the actual number of shared slots across different servers considering constraints: based on the aforementioned constraint matrix and formula. The dynamic programming algorithm calculates the actual number of shared slots across different servers under constraints, where P represents cluster throughput and Maximize represents maximizing. This represents the number of tasks that can run on server j, m represents the number of tasks, and n represents the number of servers. This represents the actual number of shared slots in server j. , , This represents the throughput of task i when it runs on server j with the actual number of shared slots in the space; Calculate the actual runtime scores of different tasks on different servers: based on the minimum fairness maximization formula. Calculate the actual runtime scores of different tasks on different servers; Maximize represents maximizing. This represents the task with the lowest throughput, m represents the number of tasks, and n represents the number of servers. This represents the actual runtime score of task i on server j. , , This represents the actual number of shared slots in server j. This represents the throughput of task i when running on server j with the actual number of shared slots in the space. This represents the baseline throughput of task i across all servers. Generate a task execution list: using formulas Using integer linear programming, task priorities are determined, and a task execution list is generated, where... This represents the priority of task i on server j. This represents the actual runtime score of task i on server j. This represents the round in which task i acquires computing resources on server j.

[0010] Another part of the present invention provides a method for calculating the number of shared slots across different servers, comprising the following steps: Pre-calculation of space sharing benefits: Based on the number of tasks and servers, according to the formula Calculate server efficiency under different shared slot numbers. The efficiency of server j is calculated when the number of shared slots is x, where x represents the number of shared slots and m represents the number of tasks. This represents the throughput of task i when it runs on server j with the actual number of shared slots in the space; Data structure initialization: Create them separately The dynamic programming matrix, reachability matrix, and selection record matrix are given, where m is the number of tasks and n is the number of servers. Dynamic programming state transition: Based on the pre-calculated space sharing benefits, the state transition equation is used. Calculate the new total benefit, where k represents the number of servers. s represents the number of tasks that can be assigned to server k, and s represents the total number of tasks that have already been assigned. This represents the benefits of pre-computed space sharing; Determine whether the new benefit is greater than the currently recorded benefit; If yes, update the current recorded benefit to the new benefit, record the current number of shared slots x on the server, and mark the reachable new matrix as true; if no, the current recorded benefit remains unchanged. Backtracking to determine the optimal allocation: Find the maximum value in the dynamic programming matrix, which corresponds to the total number of tasks in the optimal allocation. Backtracking then yields the number of shared slots that each server should be allocated.

[0011] Preferably, constraint-aware fair scheduling is performed between servers to allocate target servers for the highest priority tasks, including the following steps: Get the task execution list and task priority; Constructing the task assignment matrix: Based on integer linear programming, create... The task allocation matrix calculates the execution allocation of different tasks i on different servers j. Where m is the number of tasks and n is the number of servers; Determine the running allocation Is it true? If yes, the computation task will be processed on the corresponding server; otherwise, the computation task will not be processed on the server.

[0012] Preferably, the execution of round-based time-sharing dynamic adjustment is characterized by including the following steps: Retrieve tasks from the task execution list; Increase the number of times the current computing task enters the cluster; Determine whether to allocate computing resources to the current computing task in this round; If yes, increase the number of rounds for acquiring computing resources for the current computing task; otherwise, keep the number of rounds for acquiring computing resources for the current computing task unchanged.

[0013] Collect the task completion results after each round.

[0014] After each computation task is completed, the system collects, integrates, verifies, and stores the results to ensure the integrity and accuracy of the data and support subsequent data analysis and other processing workflows.

[0015] Experimental results show that, compared with traditional methods, this method achieves a significant improvement in computational efficiency while satisfying task execution constraints and effectively ensuring fairness among users. Attached Figure Description

[0016] Figure 1 This is a flowchart of the constraint-aware heterogeneous cluster fair scheduling method based on spatiotemporal sharing proposed in this application.

[0017] Figure 2 This is an architecture diagram of the constraint-aware heterogeneous cluster fair scheduling system based on spatiotemporal sharing proposed in this application.

[0018] Figure 3 A detailed description of the task constraint matrix algorithm for the embodiments of this application.

[0019] Figure 4 This is a detailed description of the task execution list generation algorithm based on space sharing and maximizing minimum fairness in the embodiments of this application.

[0020] Figure 5 This document provides a detailed description of the algorithm for calculating the number of shared slots on different servers in the embodiments of this application.

[0021] Figure 6 This is a detailed description of the time-sharing dynamic adjustment based on rounds in the embodiments of this application. Detailed Implementation

[0022] To make the technical solution of this disclosure clearer, the following will describe in detail the constraint-aware heterogeneous cluster fair scheduling method based on spatiotemporal sharing provided in this application, and explain its technical effects, in conjunction with the accompanying drawings and several exemplary embodiments.

[0023] First, let's introduce and explain several terms used in this application: Time sharing: Distributing a server resource to multiple users who take turns using it, based on time segments.

[0024] Runtime Segment: The percentage of actual time a task should run on each server.

[0025] Space sharing: Running multiple tasks simultaneously on the same server by using multi-threaded or multi-process services.

[0026] Number of shared slots: The number of tasks running simultaneously on the same server.

[0027] In one embodiment, such as Figure 1 The flowchart of the constraint-aware heterogeneous cluster fair scheduling method based on spatiotemporal sharing of the present invention is shown, including: Step R1 obtains the user's task execution request and constructs the task constraint matrix; Step R2 generates a task execution list based on the task constraint matrix, taking into account space sharing and maximizing minimum fairness. Step R3 retrieves the highest priority task from the task execution list, performs constraint-aware fair scheduling among servers, and assigns a target server to the highest priority task. Step R4 performs dynamic time-sharing adjustment based on rounds according to the constraint-aware fair scheduling result until the current round ends. If the highest priority task is completed, the highest priority task is removed from the task execution list. Steps R2-R4 are repeated until the task execution list is empty.

[0028] In one embodiment, a constraint-aware heterogeneous cluster fair scheduling system based on spatiotemporal sharing is provided, characterized by comprising: a task preprocessing module for acquiring user-submitted task execution requests and constructing a task constraint matrix; a task determination module for generating a task execution list based on the task constraint matrix, spatial sharing, and maximizing minimum fairness; an inter-server constraint-aware fair scheduling module for acquiring the highest priority task in the task execution list and allocating a target server to the task through inter-server constraint-aware fair scheduling; and an inter-server round-robin scheduling module for performing dynamic adjustment of time sharing based on rounds according to the constraint-aware fair scheduling result until the current round ends; if the highest priority task is completed, the highest priority task is removed from the task execution list, triggering the task preprocessing module, task determination module, inter-server constraint-aware fair scheduling module, and inter-server round-robin scheduling module to repeatedly execute the corresponding operations until the task execution list is empty.

[0029] In one implementation, a constraint-aware, heterogeneous cluster fair scheduling system based on spatiotemporal sharing is provided, such as... Figure 2 As shown, its specific content is as follows: The T1-T2 section is the task preprocessing module, which is responsible for obtaining the user's task execution request and constructing the task constraint matrix.

[0030] The T3 module is the task determination module, which generates a task execution list based on the task constraint matrix, space sharing, and minimizing fairness, in order to maximize cluster throughput.

[0031] The T4-T6 section is a constraint-aware fair scheduling module between servers, used to obtain the highest priority task in the task execution list, perform constraint-aware fair scheduling between servers, and assign a target server to the highest priority task.

[0032] The T7-T8 section is the inter-server round-robin scheduling module, which is responsible for dynamically adjusting the inter-server scheduling strategy based on the existing task execution status and the current server resource status to achieve efficient and fair scheduling.

[0033] The T1 section is the task status determination module, which is used to determine the arrival and completion status of task requests and manage the rounds of acquiring computing resources and entering the cluster for all tasks.

[0034] The T2 section is the task constraint construction module, used to construct the task constraint matrix.

[0035] The T4 section is the task reading module, used to read the tasks assigned to each server.

[0036] The T5 section is the scheduler module, which is used to perform constraint-aware fair scheduling based on the task constraint matrix.

[0037] The T6 section is a resource management module used to record the current load of server computing and storage resources.

[0038] The T7 section is the task scheduling loop driver submodule, which is used to drive the round-based scheduling loop.

[0039] The T8 section is the result output module, which is used to return the server's calculation results to the scheduler.

[0040] In one embodiment, such as Figure 3 The diagram shows how to obtain a user's task execution request and construct a task constraint matrix, including: Step S1 is to obtain detailed task information.

[0041] Step S2 is to determine whether the current task execution request is a newly arrived request.

[0042] Step S3 is to determine if the condition is met, and then reset the resource acquisition rounds and cluster entry rounds of all tasks to their initial states.

[0043] Step S4 is to determine whether the current task execution request is a completed request.

[0044] Step S5 involves determining if the condition is not met and then constructing the task constraint matrix.

[0045] In step S5, an m×n matrix is ​​created, and different tasks are set. different servers Running constraints To constrain Representative task On the server Is it runnable? In one embodiment, such as Figure 4 The diagram shows the task execution list generated based on space sharing and maximizing minimum fairness, including: Step 101 involves obtaining the throughput fitting function for different tasks on different servers, and defining the throughput fitting function. Where r represents the server resource allocation ratio, , This represents the additional cost fitting function. This represents the fitting function between the resource allocation ratio and the throughput.

[0046] Step 102 is to calculate the number of shared slots between different servers without considering constraints.

[0047] Step 103 is to calculate the baseline throughput of different tasks across all servers.

[0048] Step 104 is to calculate the actual number of shared slots for different servers under constraints.

[0049] Step 105 is for calculating the actual runtime scores of different tasks on different servers.

[0050] Step 106 generates the task execution list.

[0051] In step 102, the formula is used. Using dynamic programming algorithms to maximize cluster throughput P, ​​we can solve for the number of shared slots on server j. .

[0052] In step 103, the formula is used. Calculate the baseline throughput of different tasks across all servers, and use it as the denominator for task revenue normalization.

[0053] In step 104, the task constraint matrix is ​​considered, and the formula is used. Using dynamic programming algorithms to maximize cluster throughput P, ​​we can solve for the actual number of shared slots for server j. .

[0054] In step 105, task revenue is normalized using the task baseline throughput, according to the formula. To maximize throughput, minimize the number of tasks and calculate the actual runtime scores of different tasks on different servers. This represents the actual runtime score of task i on server j. , .

[0055] In step 106, the formula is used. Using integer linear programming, task priorities are determined, and a task execution list is generated, where... This represents the priority of task i on server j. This represents the actual runtime score of task i on server j. This represents the round in which task i acquires computing resources on server j.

[0056] In one embodiment, such as Figure 5 As shown, the number of shared slots across different servers is calculated, including: Step Q1 involves pre-calculating the benefits of space sharing.

[0057] Step Q2 is the initialization of the data structure.

[0058] Step Q3 involves dynamic programming for state transitions.

[0059] Step Q4 involves backtracking to determine the optimal allocation.

[0060] In step Q1, according to the formula The efficiency of server j when calculating the number of shared slots x in the computation space .

[0061] In step Q3, according to the state transition equation Calculate the new total benefit.

[0062] In one embodiment, such as Figure 6 The diagram shows the implementation of round-based time-sharing dynamic adjustments, including: Step M1 is the initial stage.

[0063] Step M2 is to obtain the task execution list.

[0064] Step M3 checks if the list is empty.

[0065] The M4 step is to determine if the condition is not met, and then retrieve the tasks from the task execution list.

[0066] Step M5 increases the number of times a task enters the cluster.

[0067] Step M6 determines whether computing resources were allocated to the task in the previous round.

[0068] Step M7 determines if the condition is met, and then increases the number of rounds for acquiring computational resources for the task.

[0069] The M8 step determines whether the task's resource acquisition rounds remain unchanged if the condition is not met.

[0070] The M9 step is a constraint-aware fair scheduling mechanism among servers.

[0071] Step M10 updates the list by removing completed tasks from the task execution list and then re-entering step M3.

[0072] Step M11 determines if the condition is met and then outputs the result.

[0073] Step M12 marks the end of the process after the calculation results are collected. In this state, all steps are dynamically adjusted based on round-based time sharing.

[0074] The embodiments described above are merely specific implementations of this application, used to illustrate the technical solution of this application, and not to limit it. The scope of protection of this application should be determined by the content of the claims. Based on the above description, those skilled in the art can make various modifications or equivalent substitutions to this application, and all such modifications or substitutions should be included within the scope of protection of this application.

[0075] Furthermore, based on the methods disclosed in this application, embodiments of this application also provide a computing device and a computer-readable storage medium. The computing device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it implements the methods described above. The storage medium stores computer instructions that cause the computing device to execute the methods described above.

Claims

1. A constraint-aware, fair scheduling method for heterogeneous clusters based on spatiotemporal sharing, characterized in that, Includes the following steps: S1. Obtain the task execution request submitted by the user and construct the task constraint matrix; S2. Based on the task constraint matrix, and combining space sharing and maximizing minimum fairness, generate a task execution list; S3. Obtain the highest priority task from the task execution list and assign a target server to the task through server constraint-aware fair scheduling. S4. Based on the constraint-aware fair scheduling result, perform round-based time sharing dynamic adjustment until the current round ends; if the highest priority task is completed, remove the highest priority task from the task execution list, and repeat steps S2-S4 until the task execution list is empty.

2. The method according to claim 1, characterized in that, Step S1 involves constructing the task constraint matrix, specifically including the following steps: Determine the status of the task request; if it is a newly arrived request, reset the resource acquisition rounds and cluster entry rounds of all tasks to their initial state; if it is a completed request, keep the resource acquisition rounds and cluster entry rounds of all tasks unchanged. Construct an m×n task constraint matrix, where m is the number of tasks, n is the number of servers, and the matrix elements are... Indicates task On the server Apply constraints on the application.

3. The method according to claim 1, characterized in that, The step S2 of generating the task execution list includes the following steps: Obtain the throughput fitting function for different tasks on different servers; Based on the throughput fitting function, calculate the space-sharing slot constraint of different servers without considering constraints. Based on the number of shared slots in the space, calculate the baseline throughput of different tasks across all servers; Based on the throughput fitting function, calculate the actual number of shared slots for different servers under constraints. Based on the actual number of shared slots and the principle of maximizing minimum fairness, calculate the actual runtime score of each task on different servers; A task execution list is generated based on the actual running time score.

4. The method according to claim 3, characterized in that, The step S2 of generating the task execution list includes the following steps: Define the resource allocation ratio and throughput fitting function as follows: ; Where r represents the server resource allocation ratio. , and The fitting parameters of the function representing the change in throughput of task i on the j-th server as a function of resource allocation ratio; Define the additional cost fitting function as: Where r represents the server resource allocation ratio, , and The fitting parameters of the function representing the change of the additional overhead of task i on the j-th server as a function of the resource allocation ratio; Define the throughput fitting function as ; Define the number of shared slots on each server j as the resource allocation ratio. reciprocal ; Calculate the number of shared slots across different servers without considering constraints: using the formula The dynamic programming algorithm is used to calculate the number of shared slots for each server without considering constraints, where P represents the cluster throughput, Maximize represents maximization, m represents the number of tasks, and n represents the number of servers. This represents the number of shared slots in server j. , , This represents the throughput of task i when it runs on server j with the number of shared slots in the space; Calculate the baseline throughput of different tasks across all servers: using the formula Calculate the baseline throughput of different tasks across all servers, where, This represents the baseline throughput of task i across all servers, where m represents the number of tasks and n represents the number of servers. This represents the number of shared slots in server j. This represents the throughput of task i when it runs on server j with the number of shared slots in the space; Calculate the actual number of shared slots across different servers considering constraints: based on the aforementioned constraint matrix and formula. The dynamic programming algorithm calculates the actual number of shared slots across different servers under constraints, where P represents cluster throughput and Maximize represents maximizing. This represents the number of tasks that can run on server j, m represents the number of tasks, and n represents the number of servers. This represents the actual number of shared slots in server j. , , This represents the throughput of task i when it runs on server j with the actual number of shared slots in the space; Calculate the actual runtime scores of different tasks on different servers: based on the minimum fairness maximization formula. Calculate the actual runtime scores of different tasks on different servers; Maximize represents maximizing. This represents the task with the lowest throughput, m represents the number of tasks, and n represents the number of servers. This represents the actual runtime score of task i on server j. , , This represents the actual number of shared slots in server j. This represents the throughput of task i when running on server j with the actual number of shared slots in the space. This represents the baseline throughput of task i across all servers. Generate a task execution list: using formulas Using integer linear programming, task priorities are determined, and a task execution list is generated, where... This represents the priority of task i on server j. This represents the actual runtime score of task i on server j. This represents the round in which task i acquires computing resources on server j.

5. The method according to claim 4, characterized in that, Calculate the number of shared slots across different servers, including the following steps: Pre-calculation of space sharing benefits: Based on the number of tasks and servers, according to the formula Calculate the pre-computed space efficiency of the server under different numbers of shared slots. The efficiency of server j is calculated when the number of shared slots is x, where x represents the number of shared slots and m represents the number of tasks. This represents the throughput of task i when it runs on server j with the actual number of shared slots in the space; Data structure initialization: Create them separately The dynamic programming matrix, reachability matrix, and selection record matrix are given, where m is the number of tasks and n is the number of servers. Dynamic programming state transition: Based on the pre-calculated space sharing benefits, the state transition equation is used. Calculate the new total benefit, where k represents the number of servers. s represents the number of tasks that can be assigned to server k, and s represents the total number of tasks that have been assigned. This represents the benefits of pre-computed space sharing; Determine whether the new benefit is greater than the currently recorded benefit; If yes, update the current recorded benefit to the new benefit, record the current number of shared slots x on the server, and mark the reachable new matrix as true; if no, the current recorded benefit remains unchanged. Backtracking to determine the optimal allocation: Find the maximum value in the dynamic programming matrix, which corresponds to the total number of tasks in the optimal allocation. Backtracking then yields the number of shared slots that each server should be allocated.

6. The method according to claim 1, characterized in that, Inter-server constraint-aware fair scheduling is performed to allocate target servers for the highest priority tasks, including the following steps: Get the task execution list and task priority; Constructing the task assignment matrix: Based on integer linear programming, create... The task allocation matrix calculates the execution allocation of different tasks i on different servers j. Where m is the number of tasks and n is the number of servers; Based on the task allocation matrix, the computation task is sent to the corresponding server for computation.

7. The method according to claim 1, characterized in that, Performing round-based dynamic adjustments for time sharing includes the following steps: Retrieve tasks from the task execution list; Increase the number of times the current computing task enters the cluster; Determine whether to allocate computing resources to the current computing task in this round; If yes, increase the number of computing resource acquisition rounds for the current computing task; otherwise, keep the number of computing resource acquisition rounds for the current computing task unchanged. Collect the task completion results after each round.

8. A constraint-aware heterogeneous cluster fair scheduling system based on spatiotemporal sharing, characterized in that, include: The task preprocessing module is used to obtain the task execution request submitted by the user and construct the task constraint matrix; The task determination module generates a task execution list based on the task constraint matrix, space sharing, and maximizing minimum fairness. The inter-server constraint-aware fair scheduling module obtains the highest priority task in the task execution list and assigns a target server to the task through inter-server constraint-aware fair scheduling. The inter-server round scheduling module performs dynamic adjustment of time sharing based on rounds according to the constraint-aware fair scheduling result until the current round ends. If the highest priority task is completed, it is removed from the task execution list, triggering the task preprocessing module, task determination module, inter-server constraint-aware fair scheduling module, and inter-server round scheduling module to repeat the corresponding operations until the task execution list is empty.

9. A constraint-aware heterogeneous cluster fair scheduling system based on spatiotemporal sharing according to claim 8, characterized in that, The task preprocessing module includes a task status determination submodule and a task constraint construction submodule. The task status determination submodule is used to determine the arrival and completion status of task requests and manage the rounds of acquiring computing resources and entering the cluster for all tasks. The task constraint construction submodule is used to construct a task constraint matrix. The inter-server constraint-aware fair scheduling module includes a computing task reading submodule, a scheduler submodule, and a resource management submodule. The computing task reading submodule is used to read the tasks allocated to each server. The scheduler submodule is used to perform constraint-aware fair scheduling based on the task constraint matrix; the resource management module is used to record the current server computing and storage resource load; the inter-server round-robin scheduling module includes a task scheduling loop driving submodule and a result output submodule; the task scheduling loop driving submodule is used to drive the round-robin-based scheduling loop; the result output module is used to return the server computing results to the scheduler.

Images