An edge computing intelligent scheduling method

Abstract

The present invention provides an edge computing intelligent scheduling method, the scheduling method comprising: step S1: obtaining resource data of edge nodes and delay data from detection points to edge nodes; step S2: analyzing scheduling tasks and obtaining analysis results; step S3: filtering out nodes that do not meet the conditions; step S4: determining the scoring formula of edge nodes; step S5: calculating the final score of the node, and then selecting the final node in combination with the node energy efficiency data. A dual-model structure with low latency and high processing performance is constructed, which supports adjusting the parameter weights in the custom model, and dynamically optimizes the parameter weights in combination with the characteristics of the scheduling task, and recommends the most suitable node for processing this task from a large number of edge nodes, so as to meet the needs of users as much as possible and improve the quality of user experience.

Description

Technical Field

[0001] The present invention relates to the field of edge cloud computing, and in particular to an edge computing intelligent scheduling method. Background Art

[0002] In the edge cloud computing platform, customers will create resources according to actual needs, such as creating a virtual machine, so as to build their own business environment and realize cloud computing applications. Most traditional cloud computing systems develop business based on the bottom layer, so when creating resources, the upper layer usually calls opentack or k8s bottom layer related interfaces to pull and create resources. When a user manages multiple bottom layers, there is a problem of which bottom layer to call to create resources faster, more conveniently, and more stably.

[0003] The traditional solution is to use task queue scheduling to quantify the service capabilities of edge computing nodes and assist users in selecting the optimal node. However, this solution cannot dynamically adjust task weights, is not stable and fast enough in the implementation process, cannot efficiently decide on the optimal node, and has low accuracy. Summary of the invention

[0004] In view of the above problems, the present invention is proposed to provide an edge computing intelligent scheduling method that overcomes the above problems or at least partially solves the above problems.

[0005] According to one aspect of the present invention, an edge computing intelligent scheduling method is provided, the scheduling method comprising:

[0006] Step S1: Obtain resource data of edge nodes and delay data from detection points to edge nodes;

[0007] Step S2: Analyze the scheduling task and obtain the analysis result;

[0008] Step S3: Filter out nodes that do not meet the conditions;

[0009] Step S4: Determine the scoring formula for edge nodes;

[0010] Step S5: Calculate the final node score, and then select the final node based on the node energy efficiency data.

[0011] Optionally, the step S1: obtaining resource data of edge nodes and delay data from detection points to edge nodes specifically includes:

[0012] Get resource data of edge nodes;

[0013] Obtain the delay data from the detection point to the edge node;

[0014] The delay data includes: the coordinates and IP of the detection point; the coordinates and IP of the edge node; the timestamp of the detection point sending the request to the edge node; and the delay of the detection point sending the request to the edge node.

[0015] Optionally, the step S2: analyzing the scheduling task and obtaining the analysis result specifically includes:

[0016] The location that the task is to serve is the location of the end user;

[0017] The amount of resources requested by the task;

[0018] Perform intelligent analysis of task characteristics based on the amount of resources requested by the task.

[0019] Optionally, the intelligent analysis of task characteristics according to the amount of resources requested by the task specifically includes:

[0020] Check whether the task has a feature classification mark;

[0021] If relevant features are given in the task, they are used directly; if the latency features are not given, the latency general type is used by default; if the resource features are not given, the resource features of the task are analyzed and the ratio of CPU to memory is calculated;

[0022] If it is 1:4, it is considered to be a universal resource type;

[0023] If it is greater than 1:4, it is considered to be resource-computing type;

[0024] If it is less than 1:4, the resource is considered to be memory type.

[0025] Optionally, the step S3: filtering out nodes that do not meet the conditions specifically includes:

[0026] Special resource filtering: If the task requires special resources, not all edge computing nodes have these resources, so filtering must be done first to exclude nodes that do not meet the conditions;

[0027] Resource filtering: If the number of resources required by a task exceeds the threshold, filtering is performed first to exclude nodes that do not meet the conditions.

[0028] Optionally, the step S4: determining the scoring formula of the edge node specifically includes:

[0029] Scoring formula: In the formula, S is the abbreviation of Score, which is the score; W is the abbreviation of Weight, which is the weight; latency is the delay; resource is the resource;

[0030] In this model, the node scoring formula is as follows:

[0031] Formula 1: S(node)=W(latency)*S(latency)+W(resource)*S(resource)

[0032] The formula is: the final node score = delay weight * delay score + resource weight * resource score;

[0033] The method of determining the value of S (latency) is described in step 5 below;

[0034] The value selection method of W (latency) and W (resource) will be explained in step 7 below;

[0035] The S (resource) scoring formula in the formula is as follows:

[0036] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*S(memory)+W(storage)*S(storage)

[0037] Compute resource scores:

[0038] Resource score = CPU weight * CPU score + memory weight * memory score + storage weight * storage score.

[0039] Optionally, the calculation method of S (latency) in the formula 1 includes:

[0040] Get the coordinate information in the task, compare it with the coordinate information of all detection points, calculate the detection point with the shortest straight-line distance, and use the data as sample data;

[0041] Get the latency performance from the detection point to each edge node and obtain the latency value:

[0042] A custom score S (latency) is given based on the obtained latency value and the commonly used latency judgment criteria.

[0043] Optionally, the calculation method of S(cpu), S(memory), and S(storage) in Formula 2 is:

[0044] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*

[0045] S(memory)+W(storage)*S(storage)

[0046] The calculation methods of CPU score S(cpu), memory score S(memory), and storage score S(storage) are as follows:

[0047] In this model, CPU, memory, and storage are selected as the basic scoring factors in the model;

[0048] The calculation method is that the higher the proportion of free resources, the higher the score. The formula is as follows:

[0049] S(cpu) = node CPU remaining / node CPU total*100;

[0050] S(memory) = node memory remaining / node memory total*100;

[0051] S(storage) = remaining node storage / total node storage*100;

[0052] The model adds other resources as basic scoring factors based on actual needs, and the calculation formula is consistent.

[0053] Optionally, W(latency) and W(resource) in Formula 1 are defined as follows:

[0054] Formula 1: S(node)=W(latency)*S(latency)+W(resource)*S(resource)

[0055] There are two weight parameters W(latency) and W(resource), W(latency)+W(resource)=1;

[0056] The weight value range is [0.3, 0.7], and the adjustment step of the management page is 0.05;

[0057] Initial default values: W(latency)=0.5, W(resource)=0.5;

[0058] The default calculation formula is: S(node)=0.5*S(latency)+0.5*S(resource);

[0059] Combined with the analysis of the task type, the weight value is dynamically adjusted based on the default value:

[0060] If it is a latency-sensitive task, W(latency) is increased by 0.1 based on the given default value, and needs to be in the range of [0.3,0.7], and W(resource) = 1-W(latency);

[0061] If it is a normal time-delay task, keep the default value unchanged;

[0062] If it is a latency-insensitive task, W(latency) is reduced by 0.1 based on the given default value, but must be in the range of [0.3,0.7], and W(resource) = 1-W(latency).

[0063] Optionally, W(cpu), W(memory), and W(storage) in Formula 2 are defined as follows:

[0064] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*

[0065] S(memory)+W(storage)*S(storage)

[0066] There are three weight parameters in Formula 2: W(cpu), W(memory), and W(storage), which correspond to the weights of CPU, memory, and storage respectively.

[0067] The present invention provides an edge computing intelligent scheduling method, the scheduling method comprising: step S1: obtaining resource data of edge nodes and delay data from detection points to edge nodes; step S2: analyzing scheduling tasks and obtaining analysis results; step S3: filtering out nodes that do not meet the conditions; step S4: determining the scoring formula of edge nodes; step S5: calculating the final score of the node, and then selecting the final node in combination with the node energy efficiency data. A dual-model structure with low latency and high processing performance is constructed, which supports adjusting the parameter weights in the custom model, and dynamically optimizes the parameter weights in combination with the characteristics of the scheduling task, and recommends the most suitable node for processing this task from a large number of edge nodes, so as to meet the needs of users as much as possible and improve the quality of user experience.

[0068] The above description is only an overview of the technical solution of the present invention. In order to more clearly understand the technical means of the present invention, it can be implemented according to the contents of the specification. In order to make the above and other purposes, features and advantages of the present invention more obvious and easy to understand, the specific implementation methods of the present invention are listed below. BRIEF DESCRIPTION OF THE DRAWINGS

[0069] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other accompanying drawings can be obtained based on these accompanying drawings without paying creative work.

[0070] Figure 1The overall architecture diagram of the system provided by the embodiment of the present invention;

[0071] Figure 2 The edge node provided in the embodiment of the present invention reports resource data to the monitoring center;

[0072] Figure 3 A detection node provided in an embodiment of the present invention sends commands at regular intervals to detect a delay graph of an edge node;

[0073] Figure 4 The detection device provided in the embodiment of the present invention uploads the acquired delay data to the monitoring platform diagram;

[0074] Figure 5 A flowchart of task analysis and scheduling provided for an embodiment of the present invention. DETAILED DESCRIPTION

[0075] The exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although the exemplary embodiments of the present disclosure are shown in the accompanying drawings, it should be understood that the present disclosure can be implemented in various forms and should not be limited by the embodiments set forth herein. On the contrary, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the present disclosure to those skilled in the art.

[0076] The terms "comprises" and "having" and any variations thereof in the description embodiments, claims and drawings of the present invention are intended to cover non-exclusive inclusions, for example, including a series of steps or units.

[0077] The technical solution of the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments.

[0078] Example 1

[0079] The system of the present invention is composed of the following four parts (as follows Figure 1-Figure 5 ):

[0080] (1) Central Scheduling Platform: used to schedule tasks to edge nodes. By calling the central monitoring platform interface, data is obtained for model calculation and the optimal edge node is recommended; the default value of the weight in the model can also be modified.

[0081] (2) Central monitoring platform: responsible for collecting statistics on the resource data of many edge nodes and the delay data from the detection device to the edge node. At the same time, it provides an interface for the central scheduling platform to retrieve data.

[0082] (3) Numerous edge nodes: The place where tasks are actually processed is essentially a cloud computing platform close to the data source; at the same time, local resource data will be uploaded to the central monitoring platform.

[0083] (4) Numerous detection points: The detection points are actual physical locations where specific equipment is deployed to detect the latency from the location to each edge node and upload the data to the central monitoring platform.

[0084] The working principle of the present invention consists of the following 9 steps:

[0085] Step 1: Obtain resource data of edge nodes and latency data from detection points to edge nodes

[0086] 1. Get the resource data of the edge node:

[0087] By deploying data collection tools (such as Prometheus) on edge nodes, node resource data is collected and reported to the monitoring platform, including but not limited to the following monitoring indicators:

[0088] Indicator Type Specific indicators CPU Total CPU, CPU usage, CPU load rate Memory Total memory, used memory storage Total storage, used storage, storage device type network Network bandwidth GPU Total GPU amount, GPU usage

[0089] Table 1: Edge node monitoring indicators

[0090] 2. Obtain the delay data from the detection point to the edge node:

[0091] Detection points refer to specific physical locations, which are generally located in the locations of end users. Assuming that the target users are distributed in Guangdong Province, Guangdong Province has 21 prefecture-level cities, including Guangzhou, Zhuhai, and Shantou. Each prefecture-level city has multiple districts, and each district has streets. Detection equipment can be deployed in districts, even down to a street or a base station.

[0092] These detection devices send commands (such as PING) to the edge nodes every hour to obtain the latency data from this detection point to each edge node, and report the data to the monitoring platform.

[0093] Latency data includes but is not limited to the following information:

[0094] * Coordinates and IP of the detection point;

[0095] * The coordinates and IP addresses of edge nodes;

[0096] *The timestamp of the probe point sending the request to the edge node;

[0097] * The delay of the detection point sending a request to the edge node (in milliseconds);

[0098] Step 2: Analyze the scheduling tasks

[0099] Note: The analysis results obtained in this step will be used in steps 7 and 8 below

[0100] 1. The location where the task is to be served, i.e. the location of the end user (such as IP or coordinates);

[0101] 2. The amount of resources requested by the task (such as CPU, memory, disk, GPU, etc.);

[0102] 3. Task characteristics, see the table below for details (Note: This item is not required to be included in the task. If it is not included, the task characteristics will be determined through the following intelligent analysis steps);

[0103] Feature Type Feature Classification Delay characteristics Delay sensitive type, delay insensitive type, delay universal type Resource characteristics Resource computing type, resource memory type, resource general type

[0104] Table 2: Scheduling task characteristics table

[0105] Steps for intelligent analysis of task characteristics:

[0106] Check whether the task has a feature classification identifier, that is, the feature classification content in the task feature table in Table 2. If the task has relevant features, use them directly; if the delay feature is not given, the default is the delay general type; if the resource feature is not given, perform the next step of calculation;

[0107] Analyze the resource characteristics of the task and calculate the ratio of CPU to memory.

[0108] If it is 1:4, it is considered to be a universal resource type;

[0109] If it is greater than this ratio, such as 1:2, it is considered to be resource computing type;

[0110] If it is less than this ratio, such as 1:8, the resource is considered to be memory type;

[0111] Step 3: Filter out nodes that do not meet the criteria:

[0112] 1. Special resource filtering: If the task requires special resources, such as GPU, enhanced network card, SSD disk, etc., not all edge computing nodes have these resources, so you need to filter them first to exclude nodes that do not meet the conditions;

[0113] 2. Resource filtering: If the task requires more resources, such as a 512c CPU and 12T hard disk space, not all edge computing nodes have sufficient remaining resources, so filtering is required to exclude nodes that do not meet the requirements.

[0114] Step 4: Edge Node Scoring Formula Note: 1. The final recommended edge node is the node with the highest score after scoring the nodes;

[0115] 2. This step provides a scoring formula. In the formula, S is the abbreviation of Score, which represents the score; W is the abbreviation of Weight, which represents the weight; latency represents the delay; and resource represents the resource.

[0116] 1. In this model, the node scoring formula is as follows:

[0117] Formula 1: S(node)=W(latency)*S(latency)+W(resource)*S(resource)

[0118] The formula indicates that: the final node score = delay weight * delay score + resource weight * resource score

[0119] The method of determining the value of S (latency) is described in step 5 below;

[0120] The values ​​of W(latency) and W(resource) will be described in step 7 below. The scoring formula of S(resource) is as follows:

[0121] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*S(memory)+W(storage)*S(storage)

[0122] This formula calculates the score of a resource:

[0123] Resource score = CPU weight * CPU score + memory weight * memory score + storage weight * storage score...

[0124] The values ​​of S(cpu), S(memory), S(storage), etc. will be explained in step 6 below;

[0125] The values ​​of W(cpu), W(memmory), W(storage), etc. will be explained in step 8 below;

[0126] Step 5: Calculation method of S (latency) in formula 1

[0127] S (latency) refers to the score of the latency performance from the detection point to the edge node.

[0128] The process of obtaining S(latency) is divided into three steps:

[0129] 1. Evaluate the user's location in the task and determine which detection point is closest to it:

[0130] a. Obtain the coordinate information in the task, compare it with the coordinate information of all detection points, calculate the detection point with the shortest straight-line distance, and use its data as sample data;

[0131] 2. Obtain the latency performance from the detection point to each edge node:

[0132] a. Sample data:

[0133] Take the latency statistics of the past 30 days as a sample. The latency data in step 1 above includes the following two data: the time when the probe point sends a request to the edge node, and the latency of the probe point sending a request to the edge node. One latency data item is generated every hour, so for 30 days, there are 30*24=720 items.

[0134] b. Calculation method:

[0135] Statistical data generally presents a normal distribution. If the average value of the sample data is used as the final value of the delay data, the average value may be distorted due to the excessive dispersion of the sample data, and it may not represent the actual delay. According to the concept of confidence interval in mathematics, the present invention takes the value of u+2α (u represents the average value of a set of data, and α represents the standard deviation) as the delay value. In mathematics, when the confidence interval is [u-2α, u+2α], approximately 95.4% of the data will fall within this range. When this model takes the value of u+2α as the delay value, the range of the data should fall within the range of [0, u+2α]. The probability that the data falls within the range of [0, u+2α] is equal to the probability of falling within [0, u-2α) plus the probability of falling within [u-2α, u+2α]. The probability that the data falls within [0, u-2α) is equal to (1-95.4%) / 2=2.3%. Therefore, the probability that the final data falls within the range of [0,u+2α] is approximately 95.4%+2.3%=97.7%.

[0136] 3. Obtain the latency score S (latency)

[0137] A custom score S (latency) is given based on the latency value obtained in one step and the commonly used latency judgment criteria.

[0138] Note: The first three items in the table below are commonly used delay judgment criteria, and the fourth item is a custom value

[0139]

[0140]

[0141] Step 6: Calculation method of S(cpu), S(memory), and S(storage) in formula 2:

[0142] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*S(memory)+W(storage)*S(storage)

[0143] The calculation methods of CPU score S(cpu), memory score S(memory), and storage score S(storage) are as follows:

[0144] There are many types of edge node resources. In this model, CPU, memory, and storage are selected as the basic scoring factors in the model. The higher the proportion of free resources, the higher the score. The formula is as follows (the result is rounded to 2 decimal places):

[0145] S(cpu) = node CPU remaining / node CPU total*100;

[0146] S(memory) = node memory remaining / node memory total*100;

[0147] S(storage) = remaining node storage / total node storage*100;

[0148] The model can also add other resources as basic scoring factors according to actual needs, and the calculation formula is the same.

[0149] Step 7: Definition of W(latency) and W(resource) in Formula 1

[0150] Note: The management interface of the dispatch center, custom weight values, are as follows.

[0151] Formula 1: S(node)=W(latency)*S(latency)+W(resource)*S(resource)

[0152] There are two weight parameters W (latency) and W (resource) in this formula, and the present invention requires:

[0153] *W(latency)+W(resource)=1;

[0154] *The weight value range is [0.3, 0.7], and the adjustment step size on the management page is 0.05.

[0155] *Initial default values: W(latency)=0.5, W(resource)=0.5

[0156] *The default calculation formula is: S(node)=0.5*S(latency)+0.5*S(resource)

[0157] 2. Combined with the analysis of the task type in step 2, dynamically adjust the weight value based on the default value:

[0158] a. If it is a latency-sensitive task, W(latency) is increased by 0.1 based on the given default value, but it must be in the range of [0.3,0.7], and W(resource) = 1-W(latency);

[0159] b. If it is a normal time-delay task, keep the default value unchanged;

[0160] c. If it is a latency-insensitive task, W(latency) is reduced by 0.1 based on the given default value, but it must be in the range of [0.3,0.7], and W(resource) = 1-W(latency);

[0161] Step 8: Definition of W(cpu), W(memory), and W(storage) in Formula 2

[0162] Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)*S(memory)+W(storage)*S(storage)

[0163] There are three weight parameters in this formula: W(cpu), W(memory), and W(storage), which correspond to the weights of CPU, memory, and storage respectively.

[0164] The present invention requires:

[0165] W(cpu)+W(memory)+W(storage)=1,

[0166] The range of W(XXX) is in [0.2,0.5], and the adjustment step is 0.05.

[0167] Initial default values: W(cpu)=0.35, W(memory)=0.35, W(storage)=0.3

[0168] Default calculation formula: S(resource)=0.35*S(cpu)+0.35*S(memory)+0.3*S(storage)

[0169] Combined with the analysis of the task type in step 2, the weight value is dynamically adjusted based on the default value:

[0170] A. If it is a computing task, modify the W(cpu) value by adding 0.1 to the base value, and within the range of [0.2,0.5], the corresponding W(storage) = 1-W(cpu)-W(memory);

[0171] B. If it is a normal task, keep the default value unchanged;

[0172] C. If it is a memory task, modify the W(memory) value, increase it by 0.1, and within the range of [0.2,0.5], the corresponding W(storage) = 1-W(cpu)-W(memory);

[0173] Step 9: Calculate the score and recommend nodes based on the node energy efficiency data

[0174] According to the formula and parameter calculation method given in the above steps, the final score of the node is calculated, and then combined with the energy efficiency data obtained from the monitoring center, the final node is selected.

[0175] The selection rules are as follows:

[0176] 1. Sort the nodes from high to low by score, and select the top three nodes with the highest scores; then calculate the score difference between the second and third scoring nodes and the first ranking node. If the score difference is greater than 5, exclude the node.

[0177] For example, there are five edge nodes A, B, C, D, and E, and their scores are 83, 92, 90.5, 77, and 86, respectively. The top three nodes are B (92), C (90.5), and E (86), respectively. Then, because the difference between E (86) and B (92) is 6 points, node E is eliminated. After elimination, the remaining nodes to be selected are B and C.

[0178] If there is only one node left in the previous step, then this node is directly used as the final recommended node; otherwise, the energy efficiency index data of the candidate nodes is obtained from the monitoring center (the PUE index is used in the present invention), and the node with the PUE value closest to 1 is selected as the final recommended node.

[0179] Example 2

[0180] 1) Data collection

[0181] a: Resource data on edge nodes: Assuming there are 4 edge nodes in total, the resource situation is as follows:

[0182]

[0183] b: Delay data between monitoring points and edge nodes: Assuming there are 10 monitoring points in total, the network delay values ​​to 4 nodes are:

[0184] Note: Since the source data sample is too large, the delay value assumed here is the calculated u+2α value (unit: milliseconds)

[0185] Edge Node A Edge Node B Edge Node C Edge Node D Monitoring point 1 54 71 47 130 Monitoring point 2 28 25 45 77 Monitoring point 3 26 68 23 98 Monitoring point 4 93 93 59 62 Monitoring point 5 48 18 16 61 Monitoring point 6 57 82 72 210 Monitoring point 7 113 55 82 87 Monitoring point 8 10 77 35 212 Monitoring point 9 114 98 84 267 Monitoring point 10 134 75 69 179

[0186] 2) Task Analysis

[0187] Assume that the task to be scheduled is:

[0188] Resource requirements are: 16-core CPU, 32GB memory, 300GB hard disk space and 1 GPU;

[0189] Task characteristics: delay sensitive;

[0190] End user location: Assumed to be closest to monitoring point 2.

[0191] Task Analysis:

[0192] The task is given the characteristic of being latency sensitive, and then the required CPU and memory ratio is calculated, the result is 1:2, so this task is also a resource computing task.

[0193] 3) Node filtering

[0194] This task requires 1 GPU resource. Since node B has no remaining GPU resources, node B is filtered. After this step, A, C, and D are left as candidate nodes.

[0195] 4) Calculate S(latency)

[0196] Take the delay from monitoring point 2 to edge nodes A, C, and D, and compare the score table to get:

[0197] Edge Node Delay value Score Edge Node A 28 100 Edge Node C 45 90 Edge Node D 77 70

[0198] The scoring formula becomes:

[0199] Edge Node Score Edge Node A W(latency)*100+W(resource)*S(resource) Edge Node C W(latency)*90+W(resource)*S(resource) Edge Node D W(latency)*70+W(resource)*S(resource)

[0200] 5) Calculate S(cpu), S(memory), S(storage)

[0201] Edge Node S(cpu) S(memory) S(storage) Edge Node A 75 70 60 Edge Node C 80 83 60 Edge Node D 50 25 62.5

[0202] 6) Calculate W(latency), W(resource)

[0203] According to the default weights, W(latency)=0.5, W(resource)=0.5

[0204] In addition, because the task is latency sensitive, W (latency) is increased by 0.1 to 0.6, and the corresponding W (resource) becomes 0.4;

[0205] The node scoring formula becomes S(node)=0.6*S(latency)+0.4*S(resource)

[0206] The scoring formula becomes:

[0207] Edge Node Score Edge Node A 0.6*100+0.4*S(resource) Edge Node C 0.6*90+0.4*S(resource) Edge Node D 0.6*70+0.4*S(resource)

[0208] 7) Calculate W(cpu), W(memory), W(storage)

[0209] According to the default weights: W(cpu) = 0.35, W(memory) = 0.35, W(storage) = 0.3. In addition, because the task is computational, W(cpu) is increased by 0.1 to 0.45, W(memory) remains unchanged, and the corresponding W(storage) becomes 0.2.

[0210] 8) Calculate the final score of the node:

[0211] Combined with the S(cpu), S(memory), and S(storage) calculated above. So

[0212] Node A: S(resource)=0.45*75+0.35*70+0.2*60=70.25

[0213] Node C: S(resource)=0.45*80+0.35*83+0.2*60=77.05

[0214] Node D: S(resource)=0.45*50+0.35*25+0.2*62.5=43.75

[0215] Substitute the S (resource) value into the final node scoring formula:

[0216] S(node_A)=0.6*100+0.4*70.25=88.1

[0217] S(node_C)=0.6*90+0.4*77.05=84.82

[0218] S(node_D)=0.6*70+0.4*43.75=59.5According to the rules, first select the top 3 nodes in descending order of scores, because there are only 3 nodes left, all of which meet the conditions; then, remove the nodes with a difference of more than 5 points from the highest-scoring node, and node D is excluded, leaving nodes A and C. Finally, according to the energy consumption monitoring data PUE (node ​​A's PUE=1.37, node C's PUE=1.22), because node C's PUE value is closer to 1, node C is finally selected as the final scheduling node.

[0219] 9) Create resources on the interface:

[0220] The above steps 1 to 8 are the overall logic of the backend algorithm of the cloud platform system. The optimal node is calculated from the algorithm and automatically pushed out when creating resources in the cloud platform interface, so that resources are pulled from the optimal node when creating resources, realizing intelligent resource scheduling.

[0221] Beneficial effect: Through the solution of the present invention, there is no need to rely on traditional task queues. Instead, a dual-model structure with low latency and high processing performance is constructed to support the adjustment of parameter weights in custom models. In combination with the characteristics of scheduling tasks, the parameter weights are dynamically optimized to recommend the most suitable node for processing this task from among many edge nodes, so as to meet user needs as much as possible and improve the quality of user experience.

[0222] The above specific implementation methods further illustrate the objectives, technical solutions and beneficial effects of the present invention in detail. It should be understood that the above are only specific implementation methods of the present invention and are not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. An edge computing intelligent scheduling method, characterized in that: The scheduling method comprises: Step S1: Obtain resource data of edge nodes and delay data from detection points to edge nodes; Step S2: Analyze the scheduling task and obtain the analysis results, including: The location that the task is to serve is the location of the end user; The amount of resources requested by the task; Intelligent analysis of task characteristics based on the amount of resources requested by the task, including: Check whether the task has a feature classification mark; If relevant features are given in the task, they are used directly; if the latency features are not given, the latency general type is used by default; if the resource features are not given, the resource features of the task are analyzed to calculate the ratio of CPU and memory; If it is 1:4, it is considered to be a universal resource type; If it is greater than 1:4, it is considered to be resource-computing type; If it is less than 1:4, it is considered as resource memory type; Step S3: Filter out nodes that do not meet the conditions; Step S4: Determine the scoring formula of the edge node, including: Scoring formula: In the formula, S is the abbreviation of Score, which is the score; W is the abbreviation of Weight, which is the weight; latency is the delay; resource is the resource; In this model, the node score formula is as follows: Formula 1: S(node)=W(latency)*S(latency)+W(resource)*S(resource) The formula means: Node score = latency weight * latency score + resource weight * resource score; Among them, S (resource) in the formula is calculated as follows: Formula 2: S(resource)=W(cpu)*S(cpu)+W(memory)* S(memory)+W(storage)*S(storage) Compute resource scores: Resource score = cpu weight * cpu score + memory weight * memory score + storage weight * storage score; The calculation method of S (latency) in the formula 1 includes: Get the coordinate information in the task, compare it with the coordinate information of all detection points, calculate the detection point with the shortest straight-line distance, and use the data of its detection point as sample data; Obtain the delay performance from the detection point to each edge node and obtain the delay value; According to the obtained latency value and the preset latency judgment standard, a custom score S (latency) is given; There are five weight parameters in Formula 1 and Formula 2, namely W (latency), W (resource), W (memory), W (storage) and W (cpu); Among them, W(latency)+W(resource)=1, W(cpu)+W(memory)+W(storage)=1; the initial default values ​​of weight parameters are: W(latency)=0.5, W(resource)=0.5; W(cpu)=0.35, W(memory)=0.35, W(storage)=0.3; The default calculation formula of Formula 1 is: S(node)=0.5*S(latency)+0.5*S(resource); The default calculation formula of Formula 2 is: S(resource)=0.35*S(cpu)+ 0.35*S(memory)+0.3*S(storage); Combined with the analysis of the task type, the weight value is dynamically adjusted based on the default value: If it is a latency-sensitive task, W(latency) is increased by 0.1 based on the given default value, and W(resource) = 1-W(latency); If it is a general-purpose latency task, W(latency) and W(resource) remain at their default values; If it is a latency-insensitive task, W(latency) is reduced by 0.1 based on the given default value, and W(resource) = 1-W(latency); If it is a resource computing task, modify the value of W(cpu) by increasing it by 0.1 based on the default value and within the range of [0.2,0.5]. The corresponding W(storage) = 1-W(cpu)-W(memory); If it is a resource-general task, keep the default values ​​of the weight parameters W(storage), W(cpu), and W(memory) unchanged; If it is a resource memory task, modify the value of W(memory) by increasing it by 0.1 based on the default value and within the range of [0.2,0.5]. The corresponding W(storage) = 1-W(cpu)-W(memory); Step S5: Calculate the node scores and select the final nodes based on the node energy efficiency data.

2. According to claim 1, an edge computing intelligent scheduling method is characterized in that: The step S1: obtaining resource data of edge nodes and delay data from detection points to edge nodes, includes: Get resource data of edge nodes; Obtain the delay data from the detection point to the edge node; The delay data includes: the coordinates and IP of the detection point; the coordinates and IP of the edge node; the timestamp of the detection point sending the request to the edge node; and the delay of the detection point sending the request to the edge node.

3. The edge computing intelligent scheduling method according to claim 1, characterized in that: The step S3: filtering out nodes that do not meet the conditions specifically includes: Special resource filtering: If the task requires special resources, not all edge computing nodes have these resources, so filtering must be done first to exclude nodes that do not meet the conditions; Resource filtering: If the number of resources required by a task exceeds the threshold, filtering is performed first to exclude nodes that do not meet the conditions.

4. The edge computing intelligent scheduling method according to claim 1, characterized in that: The calculation method of S(cpu), S(memory), and S(storage) in the above formula 2 adopts the method that the higher the proportion of free resources, the higher the score. The formula is as follows S(cpu) = (node ​​CPU remaining / node CPU total) * 100; S(memory) = (node ​​memory remaining / node memory total) * 100; S(storage)=(node ​​storage remaining amount / node storage total amount)*100.

Images