Method for dynamically allocating heterogeneous computing resources facing ocean supercomputing environment

Abstract

The present application relates to the technical field of marine information processing, and specifically relates to a heterogeneous computing resource dynamic allocation method for a marine supercomputing environment, comprising the following steps: S1: real-time monitoring of dynamic demand characteristics of marine data processing tasks, including task computing amount and task real-time level; S2: dynamically calibrating task priority; S3: screening out target resources that simultaneously meet the task computing amount requirement and the response speed and real-time level match; S4: allocating the task to the target resources; S5: if the load rate of the target resources exceeds the preset threshold, triggering resource reallocation; S6: outputting the final resource allocation scheme, and recording the completion time of the corresponding task and the utilization rate of each computing resource. Through the task priority driven dynamic scheduling and real-time load perception reallocation mechanism, the present application realizes the time-effect guarantee of key tasks and the efficient use of heterogeneous resources in the marine supercomputing environment.

Description

Technical Field

[0001] This invention relates to the field of marine information processing technology, and in particular to a method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments. Background Technology

[0002] As the requirements for real-time performance and computational accuracy in marine observation, simulation, early warning, and analysis tasks continue to increase, marine scientific research and engineering decision-making increasingly rely on supercomputing platforms for the rapid processing and high-frequency scheduling of massive amounts of data. Currently, supercomputing environments for marine applications mostly adopt heterogeneous computing architectures, covering multiple types of computing nodes such as CPUs, GPUs, and FPGAs, to adapt to the concurrent execution requirements of different task models. However, due to the significant differences in computational intensity and response time among various tasks, the use of static resource scheduling strategies often leads to uneven resource utilization and delayed execution of critical tasks, severely restricting the overall system operating efficiency and task completion quality.

[0003] Existing technologies often lack fine-grained identification of dynamic computing needs and real-time requirements during resource scheduling. They cannot accurately match heterogeneous computing resources based on task priority, nor do they form a complete resource reallocation mechanism to cope with resource overload. Especially in the high-frequency changing marine mission environment, traditional scheduling methods struggle to perceive resource load fluctuations in real time and dynamically adjust task deployment locations, leading to delays for high-priority tasks and system bottlenecks. Therefore, a dynamic allocation method for heterogeneous computing resources in marine supercomputing environments is urgently needed to address these issues. Summary of the Invention

[0004] To achieve the above objectives, this invention provides a method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments.

[0005] A method for dynamic allocation of heterogeneous computing resources in marine supercomputing environments includes the following steps:

[0006] S1: Real-time monitoring of the dynamic requirements of marine data processing tasks, including task computation volume and task real-time level;

[0007] S2: Dynamically assign task priorities based on the computational load and real-time requirements in S1;

[0008] S3: Based on task priority, scan the current heterogeneous computing power resource pool and select target resources that simultaneously meet the task's computational requirements and match the response speed and real-time level.

[0009] S4: Assign tasks to target resources and monitor the load rate changes of target resources in real time;

[0010] S5: If the load rate of the target resource exceeds the preset threshold, resource reallocation will be triggered, and low-priority tasks will be migrated to other available computing resources first.

[0011] S6: Output the final resource allocation scheme and record the completion time of the corresponding tasks and the utilization rate of each computing resource.

[0012] Optionally, S1 specifically includes:

[0013] S11: Receive the description information of the task to be executed through the marine supercomputing task scheduling interface, and extract the source code call graph, input data scale identifier and user-set deadline;

[0014] S12: Call the static instruction counter analyzer to perform node-by-node instruction statistics on the source code call graph, and combine it with the input data scale identifier to obtain the task computational quantity value using a linear upscaling model;

[0015] S13: Calculate the difference Δt between the user-set deadline and the current time, and determine the task real-time level (Level) in the preset real-time level mapping table based on the difference Δt. Specifically, when Δt≤1s corresponds to Level L1; when 1s<Δt≤5s corresponds to Level L2; when Δt>5s corresponds to Level L3.

[0016] S14: Combine the task computation amount and the real-time level into a dynamic requirement feature data pair, write it into the requirement feature cache queue, and refresh and update it at a fixed period of 100ms.

[0017] Optionally, S12 specifically includes:

[0018] S121: Based on the task source code call graph extracted in S11, perform static instruction counting on each function node to obtain the basic instruction count for each node, denoted as... , where i is the node number;

[0019] S122: Obtain the total amount of input data D based on the input data scale identifier, and look up the corresponding scale growth coefficient from the preset scale weight table. ;

[0020] S123: Construct a linear upscaling model based on the total number of node instructions and the scaling factor, and calculate the numerical value of the task computational load. The formula is as follows: Where C represents the computational load of the task; This represents the data scaling factor; N represents the total number of nodes in the graph that call functions.

[0021] Optionally, S2 specifically includes:

[0022] S21: Receives the task computation amount C and real-time level L output by S1;

[0023] S22: Based on the real-time performance level L, retrieve the corresponding weight coefficient from the preset real-time weight mapping table. L1 corresponds to =0.6, L2 corresponds =0.3, L3 corresponds =0.1;

[0024] S23: Normalize the computational load C of the task to obtain the normalized computational load value. ;

[0025] S24: Will With weighting coefficients Combined with the task priority value P, its calculation formula is as follows: , where the value of P ranges from [0,1];

[0026] S25: Store the calculated priority value P into the task scheduling table and sort it in descending order of priority value. The scheduling table is updated every 500 ms.

[0027] Optionally, S3 specifically includes:

[0028] S31: Receives the task priority value P, task computation amount C, and task real-time level L output by S2, and initializes the resource scanning queue to traverse all computing nodes in the current heterogeneous computing power resource pool.

[0029] S32: Obtain the available computing power parameters for each computing node, including the current idle instruction throughput R and the current response latency T;

[0030] S33: Perform preliminary screening on each computing node and remove nodes whose current instruction throughput R is lower than the minimum processing capacity required for the task computation C;

[0031] S34: Among the nodes after initial screening, retrieve the corresponding maximum allowable response delay based on the task real-time level L. Filter out all response delay times T> Nodes;

[0032] S35: Add the remaining nodes that meet the requirements of instruction throughput and response latency to the candidate resource set, sort them from high to low instruction throughput, and select the node with the highest ranking as the target resource node to carry the current task.

[0033] Optionally, S32 specifically includes:

[0034] S321: During the monitoring period, read the hardware performance counters of the target computing node to obtain the node's current clock frequency F and instruction-level parallelism I;

[0035] S322: Calculate the theoretical peak instruction throughput of the node based on F and I. The calculation formula is: ;

[0036] S323: Call the operating system resource monitoring interface to obtain the node's current CPU utilization U, and then calculate the node's current idle instruction throughput R, using the following formula: ;

[0037] S324: Read the node task queue length Q and the node task service rate Calculate queue waiting time The formula is: ;

[0038] S325: Measure the average context switch time S of a node using a kernel timer;

[0039] S326: According to The current response delay time T of the node is obtained by combining it with S, using the following formula: .

[0040] Optionally, S4 specifically includes:

[0041] S41: The task scheduler sends a task start instruction packet to the target resource node selected in S3 via the Internet. The instruction packet includes the task identifier, input data path, required memory capacity, and execution image fingerprint.

[0042] S42: After parsing the instruction package, the target resource node calls the local container orchestration service, pulls the corresponding compute image based on the execution image fingerprint and allocates an independent namespace, then mounts the input data path and completes the instantiation of the task runtime environment;

[0043] S43: The scheduler sends the computation entry function and parameters through a zero-copy message queue. Upon receiving the message, the target resource node immediately starts the task's main thread and records the task's start timestamp.

[0044] S44: During task execution, the node's built-in resource monitoring agent calls the hardware performance counter at a 200 ms sampling period to obtain the node's current instruction throughput. Peak instruction throughput And calculate the node load rate according to the following formula. The formula is: ;

[0045] S45: Node load rate The task execution progress percentage is reported to the scheduling manager in real time via gRPC streaming channel, enabling continuous monitoring of load changes on target resource nodes.

[0046] Optionally, S5 specifically includes:

[0047] S51: The scheduler receives the current load rate reported by the target resource node. Then, compare it with the preset load rate threshold. Compare, if the conditions are met > If so, the resource reallocation process will begin immediately;

[0048] S52: The scheduler queries all tasks currently being executed in the target node and sorts them from low to high according to the priority value P of each task, and builds a list of low priority tasks;

[0049] S53: Select tasks sequentially from the low-priority task list, scan all candidate idle nodes that are not the current node in the heterogeneous computing power resource pool, and filter out nodes that simultaneously meet the task's computational requirements and response latency limits.

[0050] S54: Sort the nodes that meet the conditions from high to low according to their idle instruction throughput, select the optimal node as the target migration node, and issue a task migration instruction packet. The task migration instruction packet includes a task context snapshot, input data path mapping information and recovery image information.

[0051] S55: After receiving the instruction packet, the target migration node completes data mapping and computation image preparation, loads the original task context, and starts the migration without interrupting the task process.

[0052] S56: The scheduler updates the task scheduling table and resource mapping table, marking a valid task migration as complete.

[0053] Optionally, the preset load rate threshold The calculation formula is: ,in, This indicates the preset load rate threshold for the target resource node; This represents the average load rate of the node over the most recent P scheduling cycles; This represents the standard deviation of the load rate of the node over the most recent P scheduling cycles; This is the margin coefficient.

[0054] Optionally, S6 specifically includes:

[0055] S61: After completing the task allocation for the current batch, the scheduling manager maps each task to its assigned target resource node and constructs a resource allocation mapping table. The mapping table includes task identifier, resource node number, priority value, scheduling timestamp and estimated calculation time.

[0056] S62: After the task is completed, the target resource node sends the task completion status back to the scheduler through the node management interface, including the task identifier, the actual start timestamp and the actual end timestamp. The scheduler calculates the task completion time based on this.

[0057] S63: During task execution, the resource monitoring agent of the target resource node periodically collects local CPU utilization data. After the task is completed, the scheduler performs numerical integration and averaging on the CPU utilization data during that period to calculate the average computing power utilization during task execution.

[0058] S64: The scheduler organizes the data of the target resource number, task completion time and average computing power utilization for each task into a structured resource allocation result report and outputs it in JSON format.

[0059] The beneficial effects of this invention are:

[0060] This invention quantifies the computational load and response time of a task in real time during the task submission phase, maps the two to computable priorities, and combines a linear upscaling model and a weight mapping table to drive resource filtering. This enables high-computation-load and high-real-time-response tasks to be accurately matched with heterogeneous nodes that meet throughput and latency requirements during the first scheduling, avoiding queuing for critical tasks due to resource mismatch and effectively shortening task startup latency.

[0061] This invention monitors node load by using millisecond-level performance counting sampling and dynamic thresholding. When node overload is detected, it automatically triggers seamless migration of low-priority tasks and outputs a structured resource allocation report after the task is completed, providing data support for subsequent scheduling strategy optimization and performance modeling. This mechanism ensures balanced load on each node and efficient utilization of global resources, and reduces the risk of task delays caused by local overload. Attached Figure Description

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

[0063] Figure 1 This is a schematic diagram of the heterogeneous computing power resource dynamic allocation method according to an embodiment of the present invention;

[0064] Figure 2 This is a schematic diagram of the real-time monitoring of dynamic demand characteristics according to an embodiment of the present invention. Detailed Implementation

[0065] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments. It should also be noted that, to make the embodiments more comprehensive, the following embodiments are the best and preferred embodiments, and those skilled in the art can use other alternative methods to implement some well-known technologies; moreover, the accompanying drawings are only for more specific description of the embodiments and are not intended to specifically limit the present invention.

[0066] like Figures 1-2 As shown, the method for dynamic allocation of heterogeneous computing resources in a marine supercomputing environment includes the following steps:

[0067] S1: Real-time monitoring of the dynamic requirements of marine data processing tasks, including task computation volume and task real-time level;

[0068] S2: Based on the computational load and real-time performance level of the tasks in S1, dynamically assign task priorities, with tasks that have high computational load and high real-time performance having the highest priority.

[0069] S3: Based on task priority, scan the current heterogeneous computing power resource pool and select target resources that simultaneously meet the task's computational requirements and match the response speed and real-time level.

[0070] S4: Assign tasks to target resources and monitor the load rate changes of target resources in real time;

[0071] S5: If the load rate of the target resource exceeds the preset threshold, resource reallocation will be triggered, and low-priority tasks will be migrated to other available computing resources first.

[0072] S6: Output the final resource allocation scheme and record the completion time of the corresponding tasks and the utilization rate of each computing resource.

[0073] S1 specifically includes:

[0074] S11: Receive the description information of the task to be executed through the marine supercomputing task scheduling interface, and extract the source code call graph, input data scale identifier and user-set deadline;

[0075] S12: Call the static instruction counter analyzer to perform node-by-node instruction statistics on the source code call graph, and combine it with the input data scale identifier to obtain the task computational quantity value using a linear upscaling model;

[0076] S13: Calculate the difference Δt between the user-set deadline and the current time, and determine the task real-time level (Level) in the preset real-time level mapping table based on the difference Δt. Specifically, when Δt≤1s corresponds to Level L1; when 1s<Δt≤5s corresponds to Level L2; when Δt>5s corresponds to Level L3.

[0077] S14: The task computation volume and real-time level are combined into a dynamic requirement feature data pair, written into the requirement feature cache queue, and refreshed at a fixed period of 100ms. The above steps achieve real-time, fine-grained monitoring of task computation volume and real-time level by accurately quantifying the difference between the number of instructions in the task source code and the deadline, providing an accurate and reliable basis for subsequent priority setting and resource selection.

[0078] S12 specifically includes:

[0079] S121: Based on the task source code call graph extracted in S11, perform static instruction counting on each function node to obtain the basic instruction count for each node, denoted as... , where i is the node number;

[0080] S122: Obtain the total amount of input data D based on the input data scale identifier, and look up the corresponding scale growth coefficient from the preset scale weight table. This coefficient characterizes the linear scaling relationship between data size and task computation volume;

[0081] Table 1 Preset Scale Weights

[0082] Input data size range (MB) Corresponding scale growth coefficient α Corresponding explanation 0 < D ≤ 10 1 Basic size, default instruction quantity ratio 10 < D ≤ 50 1.2 Slight growth, mild expansion of the model 50 < D ≤ 100 1.5 For medium-scale expansion, cache hits need to be considered. 100 < D ≤ 500 1.9 Significant growth, increased I / O load D > 500 2.5 Extremely large scale, accompanied by significant memory scheduling and thread scheduling overhead.

[0083] S123: Construct a linear upscaling model based on the total number of node instructions and the scaling factor, and calculate the numerical value of the task computational load. The formula is as follows: Where C represents the computational load of the task; This represents the data scale growth coefficient; N represents the total number of function nodes in the calling graph; the above steps can efficiently quantify the task computation intensity, avoid the estimation deviation of computational requirements during task scheduling, and thus improve the accuracy and stability of resource allocation.

[0084] S2 specifically includes:

[0085] S21: Receive the task computation amount C and real-time level L output by S1, where C represents the number of millions of instructions required for task computation, and L represents the real-time level, with a value range of {L1, L2, L3}, corresponding to high, medium, and low real-time tasks respectively.

[0086] S22: Based on the real-time performance level L, retrieve the corresponding weight coefficient from the preset real-time weight mapping table. L1 corresponds to =0.6, L2 corresponds =0.3, L3 corresponds =0.1;

[0087] S23: Normalize the computational load C of the task to obtain the normalized computational load value. The calculation formula is as follows: Where C represents the computational load of the current task, in millions of instructions (MIPS). These are the minimum and maximum computational requirements for all pending tasks within the current scheduling period, respectively, in millions of instructions; The value range is [0,1];

[0088] S24: Will With weighting coefficients Combined with the task priority value P, its calculation formula is as follows: The value of P ranges from [0,1], and the larger the value, the higher the priority.

[0089] S25: Store the calculated priority value P in the task scheduling table and sort it in descending order of priority value for use in subsequent resource allocation processes. The scheduling table is updated every 500 ms. The above steps, by introducing a combination of real-time weights and computational normalization indicators, can realize a unified priority evaluation mechanism for multiple tasks under different data scales and time sensitivities. This ensures that the scheduling strategy always prioritizes critical and urgent tasks under limited resource conditions, effectively improving the efficiency of supercomputing resource utilization and the rationality of task scheduling.

[0090] S3 specifically includes:

[0091] S31: Receives the task priority value P, task computation amount C, and task real-time level L output by S2, and initializes the resource scanning queue to traverse all computing nodes in the current heterogeneous computing power resource pool.

[0092] S32: Obtain the available computing power parameters of each computing node, including the current idle instruction throughput R and the current response latency T, where the instruction throughput represents the maximum number of instructions that can be processed per unit time, and the response latency represents the average waiting time for the node to start computing after receiving the task instruction.

[0093] S33: Perform preliminary screening on each computing node and remove nodes whose current instruction throughput R is lower than the minimum processing capacity required for the task computation C;

[0094] S34: Among the nodes after initial screening, retrieve the corresponding maximum allowable response delay based on the task real-time level L. Filter out all response delay times T> Nodes;

[0095] S35: Add the remaining nodes that meet the requirements of instruction throughput and response latency to the candidate resource set, sort them from high to low instruction throughput, and select the node with the highest ranking as the target resource node to carry the current task. The above steps combine the task's computational load and real-time level to perform dual screening of nodes in the heterogeneous resource pool from two dimensions, ensuring that the selected target resource has both sufficient computing power and can complete the response processing within the task time limit, thus ensuring the response reliability and scheduling adaptability of the computing task in the high-concurrency scenario of marine supercomputing.

[0096] S32 specifically includes:

[0097] S321: During the monitoring period, read the hardware performance counters of the target computing node to obtain the node's current clock frequency F and instruction-level parallelism I;

[0098] S322: Calculate the theoretical peak instruction throughput of the node based on F and I. The calculation formula is: ;

[0099] S323: Call the operating system resource monitoring interface to obtain the node's current CPU utilization U, and then calculate the node's current idle instruction throughput R, using the following formula: ;

[0100] S324: Read the node task queue length Q and the node task service rate Calculate queue waiting time The formula is: ;

[0101] S325: Measure the average context switch time S of a node using a kernel timer;

[0102] S326: According to The current response delay time T of the node is obtained by combining it with S, using the following formula: The above steps, by jointly quantizing hardware counters and real-time monitoring data from the operating system, can accurately obtain the remaining processing power and response latency of each computing node within a millisecond period, providing a reliable data foundation for the precise matching of subsequent tasks and resources, thereby improving the real-time performance and efficiency of heterogeneous computing resource allocation.

[0103] S4 specifically includes:

[0104] S41: The task scheduler sends a task start instruction packet to the target resource node selected by S3 via the Internet. The instruction packet includes the task identifier, input data path, required memory capacity, and execution image fingerprint.

[0105] S42: After parsing the instruction package, the target resource node calls the local container orchestration service, pulls the corresponding compute image based on the execution image fingerprint and allocates an independent namespace, then mounts the input data path and completes the instantiation of the task runtime environment;

[0106] S43: The scheduler sends the computation entry function and parameters through a zero-copy message queue. Upon receiving the message, the target resource node immediately starts the task's main thread and records the task's start timestamp.

[0107] S44: During task execution, the node's built-in resource monitoring agent calls the hardware performance counter at a 200 ms sampling period to obtain the node's current instruction throughput. Peak instruction throughput And calculate the node load rate according to the following formula. The formula is: ;

[0108] S45: Node load rate The task execution progress percentage is reported to the scheduler in real time via gRPC streaming channel, enabling continuous monitoring of load changes on target resource nodes. The above steps, by using container orchestration to quickly start tasks and combining high-frequency performance counting sampling to calculate dimensionless load rate, achieve millisecond-level task delivery and real-time load transparency monitoring, enhancing the dynamic response capability and resource utilization accuracy of computing resource scheduling.

[0109] S5 specifically includes:

[0110] S51: The scheduler receives the current load rate reported by the target resource node. Then, compare it with the preset load rate threshold. Compare, if the conditions are met > If so, the resource reallocation process will begin immediately;

[0111] S52: The scheduler queries all tasks currently being executed in the target node and sorts them from low to high according to the priority value P of each task, and builds a list of low priority tasks;

[0112] S53: Select tasks sequentially from the low-priority task list, scan all candidate idle nodes that are not the current node in the heterogeneous computing power resource pool, and filter out nodes that simultaneously meet the task's computational requirements and response latency limits.

[0113] S54: Sort the nodes that meet the conditions from high to low according to their idle instruction throughput, select the optimal node as the target migration node, and issue a task migration instruction packet. The task migration instruction packet contains task context snapshot, input data path mapping information and recovery image information.

[0114] S55: After receiving the instruction packet, the target migration node completes data mapping and computation image preparation, loads the original task context, and starts the migration without interrupting the task process.

[0115] S56: The scheduler updates the task scheduling table and resource mapping table, marking the completion of a valid task migration. The above steps, by prioritizing the identification and migration of low-priority tasks and intelligently filtering target nodes based on the current resource pool status, realize a distributed computing power adaptive scheduling mechanism under the condition of target resource overload, effectively alleviating node computing bottlenecks and ensuring the running quality of high-priority tasks.

[0116] Preset load rate threshold The calculation formula is: ,in, This indicates the preset load rate threshold for the target resource node; This represents the average load rate of the node over the most recent P scheduling cycles; This represents the standard deviation of the load rate of the node over the most recent P scheduling cycles; The margin coefficient reflects the system's tolerance to load fluctuations, and its value ranges from [1.5 to 2.5]. Specifically, it is determined by the task's real-time level. When the task's real-time level is L1, the margin coefficient is 1.5; when the task's real-time level is L2, the margin coefficient is 2.0; and when the task's real-time level is L3, the margin coefficient is 2.5.

[0117] S6 specifically includes:

[0118] S61: After completing the task allocation for the current batch, the scheduler will map each task to its allocated target resource node and build a resource allocation mapping table. The mapping table includes task identifier, resource node number, priority value, scheduling timestamp and estimated calculation time.

[0119] S62: After the task is completed, the target resource node sends the task completion status back to the scheduler through the node management interface, including the task identifier, the actual start timestamp and the actual end timestamp. The scheduler calculates the task completion time based on this, and the calculation method is to subtract the task start time from the task end time.

[0120] S63: During task execution, the resource monitoring agent of the target resource node periodically collects local CPU utilization data. After the task is completed, the scheduler performs numerical integration and averaging on the CPU utilization data during that period to calculate the average computing power utilization during task execution.

[0121] S64: The scheduler organizes the target resource number, task completion time and average computing power utilization data corresponding to each task into a structured resource allocation result report and outputs it in JSON format. The above steps ensure the traceability and quantifiable analysis capability of the scheduling process by standardizing the recording of task completion time and computing power usage, and by combining structured output and historical archives.

[0122] This invention encompasses any substitutions, modifications, equivalent methods, and solutions made within the spirit and scope of this invention. To provide the public with a thorough understanding of this invention, specific details are described in detail in the following preferred embodiments; however, those skilled in the art will fully understand the invention even without these details. Furthermore, to avoid unnecessary misunderstanding of the essence of this invention, well-known methods, processes, procedures, components, and circuits are not described in detail.

[0123] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method for dynamic allocation of heterogeneous computing resources in marine supercomputing environments, characterized in that, Includes the following steps: S1: Real-time monitoring of the dynamic requirements of marine data processing tasks, including task computation volume and task real-time level; S1 specifically includes: S11: Receive the description information of the task to be executed through the marine supercomputing task scheduling interface, and extract the source code call graph, input data scale identifier and user-set deadline; S12: Call the static instruction counter analyzer to perform node-by-node instruction statistics on the source code call graph, and combine it with the input data scale identifier to obtain the task computational quantity value using a linear upscaling model; S13: Calculate the difference Δt between the user-set deadline and the current time, and determine the task real-time level (Level) in the preset real-time level mapping table based on the difference Δt. Specifically, when Δt≤1s corresponds to Level L1; when 1s<Δt≤5s corresponds to Level L2; when Δt>5s corresponds to Level L3. S14: Combine the task computation amount and the real-time level into a dynamic requirement feature data pair, write it into the requirement feature cache queue, and refresh and update it at a fixed period of 100ms. S12 specifically includes: S121: Based on the task source code call graph extracted in S11, perform static instruction counting on each function node to obtain the basic instruction count for each node, denoted as... , where i is the node number; S122: Obtain the total amount of input data D based on the input data scale identifier, and look up the corresponding scale growth coefficient from the preset scale weight table. The scale growth coefficient Characterizes the linear scaling relationship between data size and task computational load; S123: Construct a linear upscaling model based on the total number of node instructions and the scaling factor, and calculate the numerical value of the task computational load. The formula is as follows: Where C represents the computational load of the task; This represents the data scaling factor; N represents the total number of nodes in the graph that call functions. S2: Dynamically assign task priorities based on the computational load and real-time requirements in S1; S3: Based on task priority, scan the current heterogeneous computing power resource pool and select target resources that simultaneously meet the task's computational requirements and match the response speed and real-time level. S4: Assign tasks to target resources and monitor the load rate changes of target resources in real time; S5: If the load rate of the target resource exceeds the preset threshold, resource reallocation will be triggered, and low-priority tasks will be migrated to other available computing resources first. S5 specifically includes: S51: The scheduler receives the current load rate reported by the target resource node. Then, compare it with the preset load rate threshold. Compare, if the conditions are met If so, the resource reallocation process will begin immediately; S52: The scheduler queries all tasks currently being executed in the target node and sorts them from low to high according to the priority value P of each task, and builds a list of low priority tasks; S53: Select tasks sequentially from the low-priority task list, scan all candidate idle nodes that are not the current node in the heterogeneous computing power resource pool, and filter out nodes that simultaneously meet the task's computational requirements and response latency limits. S54: Sort the nodes that meet the conditions from high to low according to their idle instruction throughput, select the optimal node as the target migration node, and issue a task migration instruction packet. The task migration instruction packet includes a task context snapshot, input data path mapping information and recovery image information. S55: After receiving the instruction packet, the target migration node completes data mapping and computation image preparation, loads the original task context, and starts the migration without interrupting the task process. S56: The scheduler updates the task scheduling table and resource mapping table, and marks a valid task migration as complete; S6: Output the final resource allocation scheme and record the completion time of the corresponding tasks and the utilization rate of each computing resource.

2. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 1, characterized in that, S2 specifically includes: S21: Receives the task computation amount C and real-time level L output by S1; S22: Based on the real-time performance level L, retrieve the corresponding weight coefficient from the preset real-time weight mapping table. ,in correspond correspond correspond ; S23: Normalize the computational load C of the task to obtain the normalized computational load value. ; S24: Will With weighting coefficients Combined with the task priority value P, its calculation formula is as follows: The range of values ​​for P is . ; S25: Store the calculated priority value P into the task scheduling table and sort it in descending order of priority value. The scheduling table is updated every 500 ms.

3. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 2, characterized in that, S3 specifically includes: S31: Receives the task priority value P, task computation amount C, and task real-time level L output by S2, and initializes the resource scanning queue to traverse all computing nodes in the current heterogeneous computing power resource pool. S32: Obtain the available computing power parameters for each computing node, including the current idle instruction throughput R and the current response latency T; S33: Perform preliminary screening on each computing node and remove nodes whose current idle instruction throughput R is lower than the minimum processing capacity required for the task computation C; S34: Among the nodes after initial screening, retrieve the corresponding maximum allowable response delay based on the task real-time level L. Filter out all response delay times Nodes; S35: Add the remaining nodes that meet the requirements of idle instruction throughput and response latency to the candidate resource set, sort them from high to low according to idle instruction throughput, and select the node with the highest ranking as the target resource node to carry the current task.

4. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 3, characterized in that, Specifically, S32 includes: S321: During the monitoring period, read the hardware performance counters of the target computing node to obtain the node's current clock frequency F and instruction-level parallelism I; S322: Calculate the theoretical peak instruction throughput of the node based on F and I. The calculation formula is: ; S323: Call the operating system resource monitoring interface to obtain the node's current CPU utilization U, and then calculate the node's current idle instruction throughput R, using the following formula: ; S324: Read the node task queue length Q and the node task service rate Calculate queue waiting time The formula is: ; S325: Measure the average context switch time S of a node using a kernel timer; S326: According to The current response delay time T of the node is obtained by combining it with S, using the following formula: .

5. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 1, characterized in that, S4 specifically includes: S41: The task scheduler sends a task start instruction packet to the target resource node selected in S3 via the Internet. The instruction packet includes the task identifier, input data path, required memory capacity, and execution image fingerprint. S42: After parsing the instruction package, the target resource node calls the local container orchestration service, pulls the corresponding compute image based on the execution image fingerprint and allocates an independent namespace, then mounts the input data path and completes the instantiation of the task runtime environment; S43: The scheduler sends the computation entry function and parameters through a zero-copy message queue. Upon receiving the message, the target resource node immediately starts the task's main thread and records the task's start timestamp. S44: During task execution, the node's built-in resource monitoring agent calls the hardware performance counter at a 200 ms sampling period to obtain the node's current instruction throughput. Peak instruction throughput And calculate the node load rate according to the following formula. The formula is: ; S45: Node load rate The task execution progress percentage is reported to the scheduling manager in real time via gRPC streaming channel, enabling continuous monitoring of load changes on target resource nodes.

6. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 5, characterized in that, The preset load rate threshold The calculation formula is: ,in, This indicates the preset load rate threshold for the target resource node; This represents the average load rate of the node over the most recent P scheduling cycles; This represents the standard deviation of the load rate of the node over the most recent P scheduling cycles; This is the margin coefficient.

7. The method for dynamic allocation of heterogeneous computing resources for marine supercomputing environments according to claim 1, characterized in that, S6 specifically includes: S61: After completing the task allocation for the current batch, the scheduling manager maps each task to its assigned target resource node and constructs a resource allocation mapping table. The mapping table includes task identifier, resource node number, priority value, scheduling timestamp and estimated calculation time. S62: After the task is completed, the target resource node sends the task completion status back to the scheduler through the node management interface, including the task identifier, the actual start timestamp and the actual end timestamp. The scheduler calculates the task completion time based on this. S63: During task execution, the resource monitoring agent of the target resource node periodically collects local CPU utilization data. After the task is completed, the scheduler performs numerical integration and averaging on the CPU utilization data during that period to calculate the average computing power utilization during task execution. S64: The scheduler organizes the data of the target resource number, task completion time and average computing power utilization for each task into a structured resource allocation result report and outputs it in JSON format.

Images