A cloud-edge GPU resource scheduling management method based on a fog computing mechanism

Abstract

This invention relates to the field of cloud computing technology, and more particularly to a cloud-edge GPU resource scheduling and management method based on fog computing principles. In this invention, task data to be processed is acquired and a task data feature vector is constructed by combining it with quality of service constraints; the status of fog nodes and cloud clusters is collected to construct local and remote hardware profiles respectively; the computational fit between local and remote GPUs is calculated by combining the feature vectors and the dual-end profiles; a local residency threshold is generated based on local load parameters; when the local computational fit is not lower than the local residency threshold, computation slices are allocated on the local GPU for inference computation; when it is lower than the local residency threshold, the feature dimensionality reduction rate is dynamically determined based on remote computational fit and fidelity constraints, and the task data to be processed is pre-reduced and serialized before being unloaded to cloud computing. This invention achieves fine-grained dynamic scheduling and low-latency inference of cloud-edge GPU resources.

Description

Technical Field

[0001] This invention relates to the field of cloud computing technology, and in particular to a cloud-edge GPU resource scheduling and management method based on fog computing principles. Background Technology

[0002] With the rapid development of deep learning and IoT technologies, massive amounts of multimodal data are generated in high-real-time scenarios such as connected vehicles, industrial automation, and smart grids, making the demand for efficient GPU inference increasingly urgent. To integrate the low-latency response advantages of the edge and the high-performance computing advantages of the cloud, the industry has widely adopted a GPU scheduling architecture that coordinates fog nodes and cloud clusters. In this architecture, the core task of scheduling is to scientifically decide whether to execute GPU computation on a local fog node or offload it to a remote cloud cluster, so as to achieve a dynamic optimization balance between computing resource utilization efficiency and task response latency.

[0003] However, existing cloud-edge task allocation mechanisms have significant limitations in assessing the matching relationship between tasks and computing power nodes. Traditional solutions often rely solely on single resource metrics such as GPU utilization, or use fixed thresholds and simple network bandwidth probing for traffic allocation decisions, making it difficult to accurately quantify the overall performance difference between local and cloud execution. Such solutions are prone to task mismatch—high-latency sensitive tasks may be assigned to cloud links with congested transmission paths, or be forcibly retained even when the local GPU has reached its physical computing power bottleneck. This fails to achieve adaptive traffic allocation between tasks and GPU computing power nodes, thus limiting the overall performance of cloud-edge collaborative GPU scheduling systems. Summary of the Invention

[0004] To overcome the above shortcomings, this invention provides a cloud-edge GPU resource scheduling and management method based on fog computing theory, which aims to improve the problem of task mismatch caused by the single basis and lack of comprehensive computing adaptability evaluation in the existing cloud-edge task allocation mechanism.

[0005] This invention provides the following technical solution: a cloud-edge GPU resource scheduling and management method based on fog computing theory, comprising: S1. Obtain the task data to be processed input from the source device, extract the computational requirement features and service quality constraints of the task data, and construct the task data feature vector; S2. Obtain the real-time working status of the local GPU resources of the fog computing node to build a local hardware profile, and obtain the computing power status and communication link status of the GPU resources of the cloud server cluster to build a remote hardware profile. S3. Based on the task data feature vector, and combined with the local hardware profile and the remote hardware profile, calculate the first computational adaptation degree of the task data to be processed on the local GPU and the second computational adaptation degree of the cloud GPU. S4. Generate a local residency threshold based on the load parameters of the local hardware profile; S5. Compare the first computational adaptation degree with the local residency threshold. If the first computational adaptation degree is greater than or equal to the local residency threshold, then divide the local GPU into computational slices and perform inference computation on the task data to be processed. S6. If the first computational adaptation degree is less than the local residency threshold, the feature dimensionality reduction rate is dynamically determined based on the second computational adaptation degree. After performing pre-feature dimensionality reduction on the task data to be processed according to the feature dimensionality reduction rate, the data is unloaded to the cloud server cluster for computation.

[0006] Preferably, in S1, constructing the task data feature vector includes: The data space topology and arithmetic strength of the task data to be processed are analyzed, the data modality and precision sensitivity are extracted, and the basic feature tensor is constructed. Extract the maximum tolerable latency parameter from the service quality constraints, use the maximum tolerable latency parameter as a penalty bias term, perform a concatenated mapping on the basic feature tensor, and generate the task data feature vector with fused latency sensitivity.

[0007] Preferably, in S2, constructing the local hardware profile includes: Obtain the basic specifications and dynamic operating indicators of the local GPU of the fog computing node, and calculate the idle ratio of video memory, the overall computing power margin and the power consumption margin. The local hardware profile is generated by concatenating the idle ratio of video memory, the overall computing power margin, the power consumption margin, and the current local task queue depth to represent the real-time carrying capacity of the local GPU.

[0008] Preferably, in S2, constructing the remote hardware profile includes: Receive the status synchronization message sent by the cloud server cluster, and parse it to obtain the real-time available computing power resource balance of the remote GPU node and the queuing delay of the remote task; The real-time communication link status from the fog computing node to the cloud server cluster is detected, and the uplink available transmission bandwidth and end-to-end network jitter characteristics are extracted. The real-time available computing power resources, remote task queuing delay, uplink available transmission bandwidth, and end-to-end network jitter characteristics are structured and encapsulated to generate the remote hardware profile that characterizes the comprehensive computing resources and communication transmission capabilities of the cloud.

[0009] Preferably, in S3, calculating the first computational fit of the task data to be processed on the local GPU and the second computational fit on the cloud GPU includes: The task data feature vector is mapped to the local hardware profile and the remote hardware profile respectively in the feature space to generate a first execution performance prediction value and a second execution performance prediction value. A local penalty factor is constructed based on the local hardware profile, and a cloud penalty factor is constructed based on the communication link characteristics in the remote hardware profile. The first execution performance prediction value is corrected using the local penalty factor to generate the first computational fit. The second execution performance prediction value is corrected using the cloud penalty factor, and the transmission latency overhead is used as a negative adjustment term to generate the second computational fit.

[0010] Preferably, in S4, generating a local residency threshold based on the load parameters of the local hardware profile includes: Obtain the free video memory ratio and current local task queue depth from the local hardware profile, as well as the preset GPU computing power rating of the fog computing node, and construct the current overall load rate of the fog computing node; The current overall load rate is mapped to a preset threshold range to generate the local residency threshold.

[0011] Preferably, the local residency threshold is positively correlated with the current overall load rate, and the lower limit of the local residency threshold is not lower than a preset minimum residency threshold, and the upper limit of the local residency threshold is not higher than a preset maximum residency threshold.

[0012] Preferably, in S5, dividing the local GPU into computational slices includes: Based on the precision sensitivity in the task data feature vector, determine the memory allocation quota and computing power concurrency parameters of the target computing slice; Based on the memory allocation quota and the computing power concurrency parameters, physically isolated computing power resource spaces are partitioned in the local GPU, and the computing slice is instantiated. The corresponding model weights are loaded into the computation slice, and the task data to be processed is imported to perform inference calculations independently.

[0013] Preferably, in S6, dynamically determining the feature dimensionality reduction rate based on the second calculated fit includes: Obtain the second computational fit degree and the precision sensitivity in the task data feature vector; The baseline dimensionality reduction rate of the task data to be processed is determined based on the difference between the second calculated adaptability and the preset upper limit of the unloading adaptability; wherein the difference is positively correlated with the baseline dimensionality reduction rate. The lower limit of the fidelity constraint for the task data to be processed is determined based on the accuracy sensitivity. The baseline dimensionality reduction rate is pruned and corrected based on the lower limit of the fidelity constraint to generate the target dimensionality reduction rate.

[0014] Preferably, in S6, pre-feature dimensionality reduction is performed on the task data to be processed, including: The encoder built into the fog computing node is invoked to extract features and compress dimensions of the task data to be processed according to the target dimensionality reduction rate, generating intermediate feature data. The intermediate state feature data is serialized and encapsulated, and the identification information of the target dimensionality reduction rate and the digest signature of the task data feature vector are appended to generate a data package to be unloaded. The data packet to be uninstalled is transmitted to the cloud server cluster via a network link.

[0015] The present invention has the following beneficial effects: This invention constructs a dual-end computing adaptability evaluation mechanism that integrates service quality constraints and cloud-edge hardware status. Combined with a local residency threshold generated based on dynamic comprehensive load adaptation, it achieves precise task distribution and efficient balanced scheduling between edge fog nodes and cloud server clusters. During local execution, it utilizes concurrent parameters of GPU memory and computing power to divide physically isolated computing slices, ensuring the deterministic execution of inference computation. During cloud offloading, it performs dynamic dimensionality reduction of pre-features based on network status and fidelity constraints, significantly reducing transmission load and bandwidth overhead while avoiding the collapse of model inference accuracy caused by dimensionality reduction. This solves the technical bottleneck of rigid task allocation in traditional cloud-fog architectures, significantly reduces end-to-end inference latency, and improves the service quality compliance rate and the comprehensive utilization rate of cloud-edge GPU resources. Attached Figure Description

[0016] Figure 1 This is a flowchart of a cloud-edge GPU resource scheduling and management method based on fog computing theory proposed in this invention; Figure 2 This is an architecture diagram of the cloud-fog-edge collaborative computing framework provided in an embodiment of the present invention. Detailed Implementation

[0017] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0018] Example 1 In the first embodiment of the present invention, the present invention provides a cloud-edge GPU resource scheduling and management method based on fog computing theory, such as... Figure 1 As shown, it includes the following steps: S1. Obtain the task data to be processed input from the source device, extract the computational requirement features and service quality constraints of the task data, and construct the task data feature vector; Preferably, in S1, constructing the task data feature vector includes: The data space topology and arithmetic strength of the task data to be processed are analyzed, the data modality and precision sensitivity are extracted, and the basic feature tensor is constructed. Extract the maximum tolerable latency parameter from the service quality constraints, use the maximum tolerable latency parameter as a penalty bias term, perform a concatenated mapping on the basic feature tensor, and generate the task data feature vector with fused latency sensitivity.

[0019] Specifically, in step S1, the architecture diagram of the cloud-fog-edge collaborative computing framework of the present invention is as follows: Figure 2 As shown, the fog computing node receives task data to be processed transmitted from the source device via a network interface. The source device can be an industrial camera, a vehicle-mounted sensing terminal, or a smart grid monitoring device. After the task data is input, the system analyzes and extracts its computational requirements and quality of service constraints to construct a task data feature vector that characterizes the comprehensive attributes of the task.

[0020] In one specific embodiment, the specific implementation process for constructing the task data feature vector is as follows: The system analyzes the data space topology and arithmetic strength of the task data to be processed, extracts data modalities and precision sensitivity, and constructs a basic feature tensor. The system analyzes the data space topology of the task data to be processed, extracting its input spatial dimensions and channel dimensions. The system simultaneously analyzes the arithmetic strength of the task data, defined as the number of floating-point operations corresponding to a unit data transmission volume. Based on this, data modalities and precision sensitivity parameters are extracted: data modalities are represented using numerical encoding, with visual modal encoding set to 1.0, audio modal encoding set to 2.0, and sensor temporal modal encoding set to 3.0. Precision sensitivity is used to characterize the dependence of the inference model on computational precision, with a value range between 0.0 and 1.0. Combining the above parameters, a basic feature tensor is constructed. , in the formula, Represents the fundamental feature tensor. Represents the data modal encoding value. Indicates arithmetic strength. This indicates precision sensitivity. The formula transforms unstructured task data features into a standardized one-dimensional feature tensor, enabling quantitative representation and comparison of different types of tasks within a unified data dimension.

[0021] Subsequently, the maximum tolerable latency parameter is extracted from the quality of service constraints. This parameter is then used as a penalty bias term to perform a concatenated mapping on the basic feature tensor, generating a task data feature vector with fused latency sensitivity. The system unpacks the quality of service constraints and extracts the maximum tolerable latency parameter. To quantify the latency sensitivity of a task, a penalty bias term is constructed. The calculation formula is as follows: ; In the formula, Indicates the penalty bias term; This represents the maximum tolerable delay parameter; This represents a preset standard reference delay, which is set to 10 milliseconds in one embodiment; This represents the latency adjustment factor, which is set to 2.5 in one embodiment. The formula quantifies the latency urgency of a task by calculating the ratio of the standard baseline latency to the task's maximum tolerable latency. The shorter the maximum tolerable latency of a task, the larger the calculated penalty bias value, indicating that the task is more sensitive to execution latency and needs to receive a higher priority in subsequent resource scheduling decisions.

[0022] Finally, the calculated penalty bias term With fundamental feature tensor Perform cascaded mapping to generate task data feature vectors. The calculation formula is as follows: ; In the formula, This represents the feature vector of task data that is sensitive to fusion latency. This represents vector concatenation and cascading mapping operations.

[0023] S2. Obtain the real-time working status of the local GPU resources of the fog computing node to build a local hardware profile, and obtain the computing power status and communication link status of the GPU resources of the cloud server cluster to build a remote hardware profile. Preferably, in S2, constructing the local hardware profile includes: Obtain the basic specifications and dynamic operating indicators of the local GPU of the fog computing node, and calculate the idle ratio of video memory, the overall computing power margin and the power consumption margin. The local hardware profile is generated by concatenating the idle ratio of video memory, the overall computing power margin, the power consumption margin, and the current local task queue depth to represent the real-time carrying capacity of the local GPU.

[0024] Preferably, in S2, constructing the remote hardware profile includes: Receive the status synchronization message sent by the cloud server cluster, and parse it to obtain the real-time available computing power resource balance of the remote GPU node and the queuing delay of the remote task; The real-time communication link status from the fog computing node to the cloud server cluster is detected, and the uplink available transmission bandwidth and end-to-end network jitter characteristics are extracted. The real-time available computing power resources, remote task queuing delay, uplink available transmission bandwidth, and end-to-end network jitter characteristics are structured and encapsulated to generate the remote hardware profile that characterizes the comprehensive computing resources and communication transmission capabilities of the cloud.

[0025] Specifically, in step S2, the system acquires in parallel the real-time working status of the local GPU resources of the fog computing node and the computing power and network status of the GPU resources of the cloud server cluster, and constructs local hardware profiles and remote hardware profiles to reflect the edge and cloud carrying capacity, respectively. In a specific embodiment, the specific implementation process of constructing local hardware profiles and remote hardware profiles is as follows.

[0026] To build a local hardware profile, fog computing nodes call underlying hardware management interfaces (such as the NVIDIA Management Library interface) to periodically collect the physical attributes and operating status of the local GPU. Basic specifications include the total physical memory and rated thermal design power (TDP) of the GPU; dynamic operating metrics include currently used memory, current core utilization, current actual power consumption, and current local task queue depth. In one embodiment, the total physical memory is preset to 24 gigabytes, and the rated TDP is set to 250 watts.

[0027] The collected data is used to calculate the percentage of free video memory, the overall computing power margin, and the power consumption margin. (Video memory free ratio) The calculation formula is as follows: ; In the formula, Indicates the percentage of free video memory; This indicates the total amount of physical video memory in the local GPU; This indicates the amount of video memory currently in use.

[0028] Overall computing power margin The calculation formula is as follows: ; In the formula, This represents the overall computing power margin; This indicates the current computing utilization of the local GPU core, with a value range between 0.0 and 1.0.

[0029] Power margin The calculation formula is as follows: ; In the formula, Indicates power margin; Indicates the rated thermal design power of the local GPU; This indicates the current actual operating power consumption.

[0030] By concatenating features such as the proportion of free video memory, the overall computing power margin, the power consumption margin, and the current local task queue depth, a local hardware profile representing the real-time carrying capacity of the local GPU is generated. ,in, This indicates the local hardware profile; This indicates the number of tasks waiting to be processed in the current local task queue.

[0031] To construct a remote hardware profile, the system receives status synchronization messages from the cloud server cluster and parses them to obtain the real-time available computing power reserves of the remote GPU nodes and the queuing latency of remote tasks. The cloud server cluster periodically sends status synchronization messages through a preset heartbeat broadcast mechanism; in one embodiment, the message sending period is set to 100 milliseconds. The fog computing node receives and unpacks the message, extracting the current total schedulable floating-point computing power reserves of the cloud server cluster. (Unit: trillion floating-point operations per second) and expected queuing latency of cloud-based task scheduling queues. (Unit: milliseconds).

[0032] The system probes the real-time communication link status between fog computing nodes and the cloud server cluster, extracting uplink available transmission bandwidth and end-to-end network jitter characteristics. Fog computing nodes establish periodic probes targeting the cloud server cluster communication interface, employing an out-of-band active probe combined with a passive packet transmission monitoring mechanism to measure the current network link performance in real time and extract uplink available transmission bandwidth. This is used to characterize the actual maximum transmission rate when fog computing nodes upload feature data packets to the cloud, with the unit set to megabits per second. It is used to extract end-to-end network jitter features. The calculation method is the standard deviation of the round-trip delay deviation of multiple consecutive probe packets, with the unit set to milliseconds. Step three involves structurally encapsulating the real-time available computing resources, remote task queuing delay, uplink available transmission bandwidth, and end-to-end network jitter characteristics to generate a remote hardware profile characterizing the comprehensive computing resources and communication transmission capabilities of the cloud. The calculation formula is as follows: ; In the formula, This represents the profile of remote hardware. The formula unifies the powerful computing power of remote cloud nodes, which are subject to network distance, with the communication constraints of the transmission channel through vectorization, ensuring that subsequent calculations of adaptability can balance the advantages of remote computing power with network transmission costs.

[0033] S3. Based on the task data feature vector, and combined with the local hardware profile and the remote hardware profile, calculate the first computational adaptation degree of the task data to be processed on the local GPU and the second computational adaptation degree of the cloud GPU. Preferably, in S3, calculating the first computational fit of the task data to be processed on the local GPU and the second computational fit on the cloud GPU includes: The task data feature vector is mapped to the local hardware profile and the remote hardware profile respectively in the feature space to generate a first execution performance prediction value and a second execution performance prediction value. A local penalty factor is constructed based on the local hardware profile, and a cloud penalty factor is constructed based on the communication link characteristics in the remote hardware profile. The first execution performance prediction value is corrected using the local penalty factor to generate the first computational fit. The second execution performance prediction value is corrected using the cloud penalty factor, and the transmission latency overhead is used as a negative adjustment term to generate the second computational fit.

[0034] Specifically, in step S3, based on the task data feature vector generated in step S1, and combined with the local hardware profile and remote hardware profile constructed in step S2, the system calculates the first computational fit of the task data to be processed on the local GPU and the second computational fit of the task data on the cloud GPU through feature space mapping and penalty correction. In a specific embodiment, the specific implementation process for calculating the first computational fit and the second computational fit is as follows.

[0035] The system performs a feature space mapping to generate a first and a second execution performance prediction value. This involves mapping the task data feature vectors to the local hardware profile and the remote hardware profile, respectively, using a non-linear feature space mapping to generate the first execution performance prediction value. Second performance prediction The calculation formula is as follows: ; ; In the formula, This represents the first predicted execution performance value; This represents the second predicted performance value. Represents the feature vector of task data; This indicates the local hardware profile; This indicates a profile of the remote hardware. and This represents the preset mapping weight matrix; and Represents the mapping bias vector; This represents a non-linear activation mapping function. In one embodiment, the Sigmoid function is used, and the output value is limited to the range of 0.0 to 1.0. This represents a vector concatenation operation. The above formula performs a high-dimensional nonlinear cross-fusion of the task's computational requirements and the hardware capabilities of the computing node to quantitatively evaluate the inherent theoretical performance gains and throughput limits of the target GPU node when processing this specific task under ideal conditions, without considering dynamic resource consumption and network transmission overhead.

[0036] To reflect resource contention and network risks during dynamic operation, the system further constructs local and cloud-based penalty factors. The local penalty factor is constructed based on the local hardware profile. The calculation formula is as follows: ; In the formula, This represents the local penalty factor, with a value range limited to 0.0 to 1.0; Indicates the current local task queue depth; The damping attenuation coefficient is set to 0.15 in one embodiment. This formula reflects the impact of local task queue backlog; the more severe the backlog, the more significant the negative inhibitory effect on local execution performance. The exponential decay form ensures that the penalty increases gradually when the queue depth is small, while the penalty approaches 1.0 when the queue depth is too large, accurately simulating the impedance effect of a sharp increase in local processing latency during periods of computing power bottleneck.

[0037] A cloud-based penalty factor is constructed based on the communication link characteristics (including uplink available transmission bandwidth and end-to-end network jitter characteristics) in the remote hardware profile. The calculation formula is as follows: ; In the formula, Indicates the cloud-based penalty factor; Indicates end-to-end network jitter characteristics; This represents the preset network jitter baseline value, which is set to 5.0 milliseconds in one embodiment; Indicates the available uplink transmission bandwidth; This indicates the maximum rated bandwidth of the communication link, which is set to 1000.0 megabits per second in one embodiment; and In one embodiment, the weighting coefficients are represented. Set to 0.4. It is set to 0.6. This formula reflects the impact that the greater the network jitter and the lower the available bandwidth, the higher the transmission uncertainty and latency risk of cloud offloading, and the greater the cloud penalty factor becomes, which is used to quantitatively reduce the theoretical benefits brought by the computing power of remote cloud nodes.

[0038] The first execution performance prediction value is corrected using a local penalty factor to generate the first computational fitness. The calculation formula is as follows: ; In the formula, This represents the first computational fit. The formula multiplies the theoretical performance prediction by the local resource availability, deducts the latency overhead caused by local queuing, and truly reflects the net fit benefit of the task in local GPU computation.

[0039] Assess the deterministic time consumption caused by data transmission and calculate the transmission delay overhead. The calculation formula is as follows: ; In the formula, Indicates transmission delay overhead; This indicates the size of the data in the task to be processed; Indicates the available uplink transmission bandwidth; This represents the latency normalization scaling factor, which is set to 0.01 in one embodiment. This formula quantifies the hard time overhead required to completely upload the original task data to the cloud. The larger the data volume or the smaller the bandwidth, the greater the obstacle effect of transmission overhead on cloud scheduling.

[0040] The second execution performance prediction is corrected using a cloud-based penalty factor, and a second computational fitness is generated by using transmission latency overhead as a negative adjustment term. The calculation formula is as follows: ; In the formula, This represents the second computational fit score. The formula integrates the theoretical computing power gains from the cloud, the risk attenuation caused by network link fluctuations, and the hard time costs incurred by data transmission, ultimately calculating the overall net fit score for task offloading to the cloud GPU cluster for computation.

[0041] S4. Generate a local residency threshold based on the load parameters of the local hardware profile; Preferably, in S4, generating a local residency threshold based on the load parameters of the local hardware profile includes: Obtain the free video memory ratio and current local task queue depth from the local hardware profile, as well as the preset GPU computing power rating of the fog computing node, and construct the current overall load rate of the fog computing node; The current overall load rate is mapped to a preset threshold range to generate the local residency threshold.

[0042] Preferably, the local residency threshold is positively correlated with the current overall load rate, and the lower limit of the local residency threshold is not lower than a preset minimum residency threshold, and the upper limit of the local residency threshold is not higher than a preset maximum residency threshold.

[0043] Specifically, in step S4, the system dynamically generates a local residency threshold for controlling whether a task remains executed on the edge side, based on the load parameters in the local hardware profile constructed in step S2. In a specific embodiment, the specific implementation process for generating the local residency threshold based on the load parameters of the local hardware profile is as follows.

[0044] The system extracts the free video memory ratio from the local hardware profile. and current local task queue depth Simultaneously, obtain the preset GPU computing power rating of the fog computing node. The current overall load rate of the fog computing nodes is calculated comprehensively. The calculation formula is as follows: ; In the formula, This indicates the current overall load factor, with a value range limited to 0.0 to 1.0. Indicates the percentage of free video memory; Indicates the current local task queue depth; This represents the preset average computing power requirement per task, which is set to 2.0 trillion floating-point operations in one embodiment. This represents the GPU computing power rating of the fog computing node, which is set to 20.0 trillion operations per second in one embodiment; and This represents the load weighting coefficient, which satisfies... In one embodiment Set to 0.4. The value is set to 0.6. This formula quantifies the load saturation of a fog compute node relative to its inherent rated processing capacity from two dimensions: static memory resource usage and dynamic compute queue queuing pressure. The closer the value is to 1.0, the more saturated the local GPU resources are.

[0045] The system is configured with a preset threshold range, which is determined by a preset minimum dwell time threshold. and maximum stay threshold Commonly defined. In one embodiment, the minimum dwell time threshold. Set to 0.20, maximum dwell time threshold. Set to 0.85. Based on the positive correlation mapping mechanism, the current overall load factor is... Mapping to the threshold range, calculate and generate the local residency threshold. The calculation formula is as follows: ; In the formula, Indicates the local residency threshold; This indicates the current overall load factor; Indicates the preset minimum dwell time threshold; This represents the preset maximum residency threshold. When a fog computing node is idle, the current overall load rate is low, and the calculated local residency threshold decreases accordingly, making it easier for tasks to meet the residency conditions and execute quickly locally. When a fog computing node is busy, the current overall load rate increases, and the local residency threshold increases accordingly, thereby raising the threshold requirement for tasks to remain locally and actively blocking unnecessary tasks and guiding them to cloud computing. At the same time, the upper and lower bound truncation mechanism of the piecewise function ensures that the local residency threshold is strictly limited between the minimum and maximum residency thresholds, preventing excessive idleness of edge resources due to excessively low thresholds, and avoiding complete rejection of local tasks by edge nodes due to excessively high thresholds.

[0046] S5. Compare the first computational adaptation degree with the local residency threshold. If the first computational adaptation degree is greater than or equal to the local residency threshold, then divide the local GPU into computational slices and perform inference computation on the task data to be processed. Preferably, in S5, dividing the local GPU into computational slices includes: Based on the precision sensitivity in the task data feature vector, determine the memory allocation quota and computing power concurrency parameters of the target computing slice; Based on the memory allocation quota and the computing power concurrency parameters, physically isolated computing power resource spaces are partitioned in the local GPU, and the computing slice is instantiated. The corresponding model weights are loaded into the computation slice, and the task data to be processed is imported to perform inference calculations independently.

[0047] Specifically, in step S5, the system compares the first computational fitness score generated in step S3 with the local residency threshold generated in step S4. When the first computational fitness score is greater than or equal to the local residency threshold, it indicates that the local GPU of the fog computing node has sufficient carrying capacity and benefit advantages. The system determines to keep the task data to be processed locally, divides the computation slices in the local GPU, and performs inference computation on the task data to be processed. In a specific embodiment, the specific implementation process of dividing the computation slices in the local GPU and performing inference computation is as follows.

[0048] The system acquires the precision sensitivity from the task data feature vector generated in step S1, and quantitatively calculates the memory allocation quota and computing power concurrency parameters of the target computing slice. Memory allocation quota The calculation formula is as follows: ; In the formula, Indicates the video memory allocation quota; This represents the single-dimensional baseline video memory quota, which is set to 512.0 megabytes in one embodiment; Indicates precision sensitivity; This represents the precision memory expansion factor, which is set to 0.5 in one embodiment. This formula jointly determines the physical memory space allocated to the computation slice based on two dimensions: the spatial order of the task data and the precision dependence of the model. Higher precision sensitivity results in larger memory footprints and activation tensors generated during inference, thus requiring a larger memory allocation to prevent memory overflow.

[0049] Computing power concurrency parameters The calculation formula is as follows: ; In the formula, This represents a computing power concurrency parameter, used to indicate the number of concurrent execution streams on the GPU; This represents the baseline concurrent flow count, which is set to 2 in one embodiment; Indicates precision sensitivity; This represents the concurrency scaling factor, which is set to 0.8 in one embodiment; This indicates a rounding up operation. The formula maps the parallel execution flow scale of the GPU computing cores based on the model's sensitivity to computational precision. Tasks with higher precision sensitivity require more parallel computing channels and core resources to ensure the throughput rate of high-precision floating-point operations.

[0050] The system calls the local GPU's underlying hardware virtualization and resource isolation interface, based on the calculated video memory allocation quota. Concurrency parameters with computing power This involves partitioning the local GPU into independent memory address spaces and streaming multiprocessor computing cores, constructing physically isolated computing resource spaces, and instantiating computing slices. During this process, hardware-level or logical-level isolation mechanisms ensure that the memory and computing resources allocated to each computing slice are not interfered with by other concurrent tasks on the local GPU, thereby achieving a deterministic inference execution environment.

[0051] After the computation slice is instantiated, the system loads the weight file of the deep learning inference model corresponding to the task data to be processed into the dedicated video memory space of the computation slice. Subsequently, the task data to be processed input from the source device is imported into the computation slice, and the model forward inference calculation is run independently using the allocated computing resources to generate and output the inference results. This process is completed in a closed loop within the local isolated computing space, without occupying cloud-edge network communication bandwidth.

[0052] S6. If the first computational adaptation degree is less than the local residency threshold, the feature dimensionality reduction rate is dynamically determined based on the second computational adaptation degree. After performing pre-feature dimensionality reduction on the task data to be processed according to the feature dimensionality reduction rate, the data is unloaded to the cloud server cluster for computation.

[0053] Preferably, in S6, dynamically determining the feature dimensionality reduction rate based on the second calculated fit includes: Obtain the second computational fit degree and the precision sensitivity in the task data feature vector; The baseline dimensionality reduction rate of the task data to be processed is determined based on the difference between the second calculated adaptability and the preset upper limit of the unloading adaptability; wherein the difference is positively correlated with the baseline dimensionality reduction rate. The lower limit of the fidelity constraint for the task data to be processed is determined based on the accuracy sensitivity. The baseline dimensionality reduction rate is pruned and corrected based on the lower limit of the fidelity constraint to generate the target dimensionality reduction rate.

[0054] Preferably, in S6, pre-feature dimensionality reduction is performed on the task data to be processed, including: The encoder built into the fog computing node is invoked to extract features and compress dimensions of the task data to be processed according to the target dimensionality reduction rate, generating intermediate feature data. The intermediate state feature data is serialized and encapsulated, and the identification information of the target dimensionality reduction rate and the digest signature of the task data feature vector are appended to generate a data package to be unloaded. The data packet to be uninstalled is transmitted to the cloud server cluster via a network link.

[0055] Specifically, in step S6, the system compares the first computational fit generated in step S3 with the local residency threshold generated in step S4. When the first computational fit is less than the local residency threshold, it indicates that the local GPU of the fog computing node is facing resource overload or performance bottlenecks and cannot meet the service quality constraints of the task. The system then determines to offload the task data to be processed to the cloud server cluster for computation. During this process, the system dynamically determines the feature dimensionality reduction rate based on the second computational fit. After performing pre-feature dimensionality reduction and packaging on the task data to be processed according to this feature dimensionality reduction rate, the data is offloaded to the cloud server cluster via the network link for final computation. In a specific embodiment, the specific implementation process of dynamically determining the feature dimensionality reduction rate based on the second computational fit and performing pre-feature dimensionality reduction and offloading on the task data to be processed is as follows.

[0056] The system retrieves the second computational fitness degree generated in step S3. Simultaneously, the task data feature vector generated in step S1 is analyzed, and the precision sensitivity is extracted from it. The baseline dimensionality reduction rate of the task data to be processed is determined based on the difference between the calculated adaptation degree and the preset upper limit of the unloading adaptation degree. The system sets a preset upper limit for the unloading adaptation degree. This upper limit represents the best fit score when the communication link and cloud computing power are in an ideal, non-blocking state. In one embodiment... Set to 1.0. Calculate the difference between the second calculated adaptability and the upper limit of the uninstall adaptability. The calculation formula is as follows: ; In the formula, Indicates the magnitude of the difference; This indicates the preset upper limit for uninstall compatibility; This represents the second calculated fitness level. Subsequently, the baseline dimensionality reduction rate is calculated based on the positive correlation mapping. The calculation formula is as follows: ; In the formula, Indicates the baseline dimensionality reduction rate; This represents the network overhead adjustment factor, which is set to 0.8 in one embodiment. This formula, by increasing the dimensionality reduction compression ratio, can effectively reduce the size of the data payload to be transmitted, thereby offsetting the transmission delay risk caused by poor network conditions.

[0057] To prevent blindly increasing the dimensionality reduction rate from causing severe loss of data features and a sharp drop in the accuracy of cloud-based model inference, the system determines a lower limit for fidelity constraints based on the accuracy sensitivity of the task data, and further derives the upper limit of the maximum allowable compression rate. The calculation formula is as follows: ; In the formula, This indicates the maximum allowed compression ratio. Indicates precision sensitivity; This represents the fidelity correction factor, set to 0.6 in one embodiment. This formula measures the task's dependence on accuracy; the higher the dependence, the lower the upper limit of data loss and feature compression it can tolerate. By using accuracy sensitivity to inversely constrain the maximum compression ratio, sufficient core semantic features and key information are preserved during data compression.

[0058] The system uses the calculated upper limit of the maximum compression ratio to adjust the baseline dimensionality reduction ratio. Perform the pruning operation to generate the final target dimensionality reduction ratio. The calculation formula is as follows: ; In the formula, This represents the target dimensionality reduction rate. The formula seeks an adaptive balance between minimizing network transmission burden and strictly ensuring the accuracy of cloud-based inference, avoiding excessive compression for high-precision-sensitive tasks.

[0059] Finally, the fog computing node loads a pre-trained lightweight built-in encoder neural network. The system inputs the task data to be processed from the source device and the calculated target dimensionality reduction rate into the built-in encoder. The built-in encoder performs multi-layer convolutional feature extraction and channel / spatial dimension compression on the task data according to the specified ratio of the target dimensionality reduction rate, transforming the original high-dimensional tensor data into low-dimensional intermediate feature data.

[0060] The system converts the generated intermediate feature data into a serialized payload in a continuous byte stream format. Based on this, a data packet header is constructed, converting the target dimensionality reduction rate and encoding format into corresponding identification information. Simultaneously, a hash digest calculation (e.g., using the SHA-256 algorithm) is performed on the task data feature vector constructed in step S1 to generate a digest signature representing the unique attributes of the task context. The identification information, digest signature, and serialized intermediate feature data are then structurally concatenated and encapsulated to generate a self-describing unloadable data packet.

[0061] Fog computing nodes invoke the network communication protocol stack to encapsulate and generate unloaded data packets, which are then transmitted to the cloud server cluster via the uplink network through a Socket interface or gRPC service link established between the cloud and the edge. Upon receiving the unloaded data packets, the cloud server cluster first parses the header to obtain identification information and a digest signature. Based on the identification information, it invokes the corresponding deep learning post-inference network header in the cloud, imports intermediate feature data, independently completes subsequent deep inference calculations, and sends the inference results back to the fog computing nodes or directly to the terminal devices, thus achieving a closed loop of resource scheduling and management for cloud-edge collaboration.

[0062] Example 2 This invention further provides Embodiment Two, which illustrates the specific application process of the cloud-edge GPU resource scheduling and management method based on fog computing mechanism in a real industrial automation visual quality inspection scenario, and compares it with the static scheduling scheme under the traditional cloud-fog architecture. The industrial application environment and equipment deployment are set up in a circuit board component surface defect detection scenario on an automated assembly line for electronic products. The system architecture is as follows: Source device: A high-frame-rate industrial camera continuously acquires high-resolution images of the PCB board via an industrial Ethernet interface. The raw data space size of a single frame image is 2048 pixels × 2048 pixels, with 3 channels and a frame rate of 60 frames per second. This task requires performing defect classification and precise location inference. The maximum tolerable latency parameter in the quality of service constraints is set to 40 milliseconds, and the accuracy sensitivity is set to 0.90.

[0063] Fog Computing Node: An edge industrial control computer deployed on the production line side, equipped with a single industrial-grade GPU, with a total physical video memory of 16 gigabytes, a rated computing power of 10.0 trillion operations per second, and a rated power consumption of 150 watts.

[0064] Cloud server cluster: A high-performance computing cluster located in the park's data center, deployed with high-performance GPU cards, connected to fog computing nodes via 5G industrial private network and wired fiber optics, with a rated uplink bandwidth of 1000 megabits per second.

[0065] To verify the technical effect of the present invention, two sets of comparative operating systems were set up: The present invention's solution group fully executes the adaptive scheduling mechanism of steps S1 to S6. Based on task feature vectors, local hardware profiles, and remote hardware profiles, it dynamically calculates the first computational fit, the second computational fit, and the local residency threshold. For local computation tasks, physically isolated computation slices are partitioned on the fog node GPU; for cloud-offloaded tasks, the baseline dimensionality reduction rate is pruned using a fidelity constraint lower bound, and after generating the target dimensionality reduction rate, it is pre-encoded and transmitted.

[0066] Traditional Comparison Solution Group: This group adopts the traditional cloud-fog architecture scheduling scheme based on static thresholds and fixed offloading strategies. Specifically, a fixed threshold is set; when the local GPU memory utilization exceeds 80% or the computational utilization exceeds 85%, the original image data is directly offloaded to the cloud; otherwise, execution is entirely on the local GPU. A fixed-ratio forced dimensionality reduction compression method is used during remote offloading.

[0067] During continuous operation of an actual production line, the system response process under the following two typical industrial operating conditions was simulated and tested: Scenario 1: Peak Production Line Period and Sudden Backlog of Edge-Side Tasks. When the production line is operating at high speed and multiple pipelines concurrently send detection tasks to the fog computing node, the local task queue depth increases rapidly. Traditional solutions forcibly allocate all newly received tasks to the local GPU before the local memory utilization reaches the 80% static threshold. Due to the lack of quantitative penalty assessment for queue waiting overhead, the local GPU computing cores are severely overloaded, resulting in a large backlog of inference tasks in the local queue. End-to-end processing latency spikes to over 120 milliseconds, significantly exceeding the maximum tolerable latency of 40 milliseconds, triggering a production line timeout alarm and causing missed workpiece inspections.

[0068] As the queue depth increases, the local penalty factor calculated in step S3 rises rapidly, significantly suppressing and reducing the first computational fit. Simultaneously, in step S4, the current overall load rate, constructed based on the idle memory ratio and queue depth, increases rapidly, driving the local residency threshold to adaptively rise. When the first computational fit drops below the local residency threshold, step S5 switches to step S6, where the system automatically blocks further task accumulation locally and promptly redirects them to the cloud server cluster for distribution, successfully preventing edge computing power collapse and task timeouts.

[0069] Scenario 2: Cloud-Edge 5G Private Network Encounters Network Jitter and Bandwidth Fluctuations. Following the cloud-based offloading of tasks triggered in Scenario 1, the wireless channel experiences electromagnetic interference from the industrial site. The available uplink transmission bandwidth from the fog node to the cloud cluster drops instantly, and network jitter increases dramatically. Traditional solutions continue to use a fixed ratio to downscale the high-resolution original image before uploading. Because the downsizing rate is not dynamically adjusted according to changes in the transmission link, a large amount of data is blocked in the transmission channel, leading to a sharp increase in transmission latency; or an excessively high fixed compression ratio is used, forcibly discarding a large amount of image details, causing a significant decrease in the accuracy of the cloud-based backend network when performing minor defect identification, resulting in misjudgments.

[0070] In step S3 of this scheme, the system detects increased network jitter and decreased bandwidth, leading to an increase in the calculated cloud penalty factor and a significant rise in transmission latency overhead. This results in a decrease in the second computational fit, a widening of the difference range, and an increase in the calculated baseline dimensionality reduction rate. This prompts the encoder to perform deeper feature compression to offset network latency. Simultaneously, step S6 retrieves the task's accuracy sensitivity of 0.90 and maps it to calculate the maximum compression rate allowed by the fidelity constraint. The system uses this upper limit to prune the baseline dimensionality reduction rate to obtain the target dimensionality reduction rate. The final generated unloaded data packet retains key features closely related to defect detection with extremely low bandwidth usage, maintaining high accuracy in cloud inference while ensuring the transmission latency meets the 40-millisecond constraint.

[0071] During a continuous 24-hour industrial operation test, the core indicators of the two schemes were quantitatively analyzed, and the comparison results are shown in Table 1.

[0072] Table 1 Performance Test Comparison of the Embodiments of the Invention and Traditional Comparison Schemes QoS latency compliance rate (less than 40ms) 68.50% 99.20% Average end-to-end inference latency 58.4 milliseconds 22.6 milliseconds Average uplink network bandwidth utilization 78.20% 31.50% Cloud-based inference defect identification accuracy 81.30% 96.80% Average GPU resource utilization (cloud-edge combined) 52.10% 88.40% In terms of latency response, by accurately offloading computational adaptation and isolating local computational slices, the system significantly reduced the average end-to-end inference latency from 58.4 milliseconds to 22.6 milliseconds, a reduction of 61.3%. Under the hard constraint of a maximum tolerable latency of 40 milliseconds, the service quality (QoS) latency compliance rate increased from 68.5% to 99.2%, significantly improving the response determinism in high real-time quality inspection scenarios.

[0073] In terms of balancing transmission and accuracy, the system performs precise dimensionality reduction based on the lower limit of fidelity constraints, reducing the average uplink network bandwidth utilization rate from 78.2% to 31.5%, saving 46.7% of communication bandwidth overhead. At the same time, it avoids excessive compression of high-precision sensitive data, increasing the cloud defect identification accuracy from 81.3% to 96.8%, successfully achieving an adaptive balance between data dimensionality reduction and inference accuracy.

[0074] In terms of resource synergy, by dynamically matching dual-end hardware profiles with local dwell thresholds, the bottleneck of local overload and idle computing power caused by traditional static traffic distribution is broken, and efficient and balanced scheduling of tasks on both cloud and fog ends is achieved, increasing the average comprehensive utilization rate of cloud-edge GPU resources from 52.1% to 88.4%, an increase of 36.3 percentage points.

[0075] The aforementioned industrial comparative data fully demonstrates that the present invention solves the technical problems of rigid task allocation, poor adaptability to network jitter, and accuracy collapse caused by data dimensionality reduction in traditional cloud-fog architecture, thereby improving the overall performance of cloud-edge collaborative GPU scheduling.

[0076] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A cloud-edge GPU resource scheduling and management method based on fog computing theory, characterized in that, include: S1. Obtain the task data to be processed input from the source device, extract the computational requirement features and service quality constraints of the task data, and construct the task data feature vector; S2. Obtain the real-time working status of the local GPU resources of the fog computing node to build a local hardware profile, and obtain the computing power status and communication link status of the GPU resources of the cloud server cluster to build a remote hardware profile. S3. Based on the task data feature vector, and combined with the local hardware profile and the remote hardware profile, calculate the first computational adaptation degree of the task data to be processed on the local GPU and the second computational adaptation degree of the cloud GPU. S4. Generate a local residency threshold based on the load parameters of the local hardware profile; S5. Compare the first computational adaptation degree with the local residency threshold. If the first computational adaptation degree is greater than or equal to the local residency threshold, then divide the local GPU into computational slices and perform inference computation on the task data to be processed. S6. If the first computational adaptation degree is less than the local residency threshold, the feature dimensionality reduction rate is dynamically determined based on the second computational adaptation degree. After performing pre-feature dimensionality reduction on the task data to be processed according to the feature dimensionality reduction rate, the data is unloaded to the cloud server cluster for computation.

2. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 1, characterized in that, In S1, the construction of the task data feature vector includes: The data space topology and arithmetic strength of the task data to be processed are analyzed, the data modality and precision sensitivity are extracted, and the basic feature tensor is constructed. Extract the maximum tolerable latency parameter from the service quality constraints, use the maximum tolerable latency parameter as a penalty bias term, perform a concatenated mapping on the basic feature tensor, and generate the task data feature vector with fused latency sensitivity.

3. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 1, characterized in that, In S2, the construction of the local hardware profile includes: Obtain the basic specifications and dynamic operating indicators of the local GPU of the fog computing node, and calculate the idle ratio of video memory, the overall computing power margin and the power consumption margin. The local hardware profile is generated by concatenating the idle ratio of video memory, the overall computing power margin, the power consumption margin, and the current local task queue depth to represent the real-time carrying capacity of the local GPU.

4. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 1, characterized in that, In S2, constructing the remote hardware profile includes: Receive the status synchronization message sent by the cloud server cluster, and parse it to obtain the real-time available computing power resource balance of the remote GPU node and the queuing delay of the remote task; The real-time communication link status from the fog computing node to the cloud server cluster is detected, and the uplink available transmission bandwidth and end-to-end network jitter characteristics are extracted. The real-time available computing power resources, remote task queuing delay, uplink available transmission bandwidth, and end-to-end network jitter characteristics are structured and encapsulated to generate the remote hardware profile that characterizes the comprehensive computing resources and communication transmission capabilities of the cloud.

5. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 1, characterized in that, In S3, calculating the first computational fit of the task data to be processed on the local GPU and the second computational fit on the cloud GPU includes: The task data feature vector is mapped to the local hardware profile and the remote hardware profile respectively in the feature space to generate a first execution performance prediction value and a second execution performance prediction value. A local penalty factor is constructed based on the local hardware profile, and a cloud penalty factor is constructed based on the communication link characteristics in the remote hardware profile. The first execution performance prediction value is corrected using the local penalty factor to generate the first computational fit. The second execution performance prediction value is corrected using the cloud penalty factor, and the transmission latency overhead is used as a negative adjustment term to generate the second computational fitness.

6. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 3, characterized in that, In S4, a local residency threshold is generated based on the load parameters of the local hardware profile, including: Obtain the free video memory ratio and current local task queue depth from the local hardware profile, as well as the preset GPU computing power rating of the fog computing node, and construct the current overall load rate of the fog computing node; The current overall load rate is mapped to a preset threshold range to generate the local residency threshold.

7. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 6, characterized in that, The local residency threshold is positively correlated with the current overall load rate, and the lower limit of the local residency threshold is not lower than the preset minimum residency threshold, and the upper limit of the local residency threshold is not higher than the preset maximum residency threshold.

8. The cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 2, characterized in that, In S5, the local GPU is divided into computation slices, including: Based on the precision sensitivity in the task data feature vector, determine the memory allocation quota and computing power concurrency parameters of the target computing slice; Based on the memory allocation quota and the computing power concurrency parameters, physically isolated computing power resource spaces are partitioned in the local GPU, and the computing slice is instantiated. The corresponding model weights are loaded into the computation slice, and the task data to be processed is imported to perform inference calculations independently.

9. A cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 2, characterized in that, In S6, the feature dimensionality reduction rate is dynamically determined based on the second calculated fitness, including: Obtain the second computational fit degree and the precision sensitivity in the task data feature vector; The baseline dimensionality reduction rate of the task data to be processed is determined based on the difference between the second calculated adaptability and the preset upper limit of the unloading adaptability; wherein the difference is positively correlated with the baseline dimensionality reduction rate. The lower limit of the fidelity constraint for the task data to be processed is determined based on the accuracy sensitivity. The baseline dimensionality reduction rate is pruned and corrected based on the lower limit of the fidelity constraint to generate the target dimensionality reduction rate.

10. A cloud-edge GPU resource scheduling and management method based on fog computing theory according to claim 9, characterized in that, In S6, the pre-feature dimensionality reduction of the task data to be processed includes: The encoder built into the fog computing node is invoked to extract features and compress dimensions of the task data to be processed according to the target dimensionality reduction rate, generating intermediate feature data. The intermediate state feature data is serialized and encapsulated, and the identification information of the target dimensionality reduction rate and the digest signature of the task data feature vector are appended to generate a data package to be unloaded. The data packet to be uninstalled is transmitted to the cloud server cluster via a network link.

Images