Weighted bipartite graph-based calculation unloading algorithm in vehicle fog calculation

Abstract

More and more time delay sensitive tasks are generated in an intelligent driving system, and how to realize quick response becomes a key challenge. Vehicle fog computing meets the low-delay requirement of a task by using a vehicle with idle computing resources as a fog node, however, the computing resources of the fog vehicle are limited, and how to schedule vehicle-mounted computing resources in a VFC architecture to meet the low-delay requirement of the task is the key point of the research in the invention. Therefore, the invention provides a calculation unloading algorithm based on a weighted bipartite graph. Firstly, a two-layer VFC framework is designed; secondly, in order to execute a resource allocation decision under the framework, tasks and fog vehicles are sequenced according to task sizes and fog vehicle performance, then the tasks and the fog vehicles are abstracted into a weighted bipartite graph to execute a Kuhn-Munkres algorithm, and then the user tasks are unloaded to the fog vehicles for calculation according to obtained maximum weight allocation. Finally, simulation result analysis shows that the proposed scheme can meet the real-time response requirement of the task, the unloading success rate is improved, and the task execution time delay is reduced.

Description

Technical Field

[0001] The present invention belongs to the field of mobile communications, and in particular to a computational offloading algorithm for vehicle fog computing. Background Art

[0002] With the rapid development of intelligent driving technology, vehicular fog computing (VFC), as a distributed computing mode, has shown significant performance advantages in improving vehicle intelligence and supporting real-time decision-making. However, in the context of intelligent driving, how to efficiently coordinate the collaboration between components in the VFC framework to further improve service quality is still one of the main challenges currently faced. First, since the intelligent driving system is highly dependent on real-time information transmission and processing in the traffic network, the distributed task computing method in the VFC architecture needs to solve a key problem - the delay problem in the process of vehicle information collection in the traffic network topology. Secondly, due to the limited resources of fog computing nodes, it is urgent to design an efficient task allocation algorithm to reasonably schedule and allocate fog computing resources, so as to maximize resource utilization and ensure the stability and efficiency of the intelligent driving system.

[0003] At present, many research papers at home and abroad have focused on the task allocation problem of vehicle fog computing, and have achieved certain results. In the literature [Wu X, Zhao S, Deng H. Joint task assignment and resource allocation in VFC based on mobility prediction information [J]. Computer Communications, 2023, 205: 24-34.], the authors proposed a two-stage computational offloading algorithm, considering defining a head vehicle and establishing a vehicle self-organizing network to manage and collect information about neighboring vehicles. At the same time, in the task allocation stage, the algorithm introduces a preference value, which is used to represent the degree of fit between the task and the fog vehicle. The higher the preference value, the greater the possibility of matching the task with the fog vehicle. In the communication resource allocation stage, machine learning is used to iteratively calculate the bandwidth allocated to each vehicle. This literature makes full use of computing resources and communication resources to reduce the task execution delay. In the literature [Zhou Z, Liao H, Zhao X, et al. Reliable task offloading for vehicular fog computing under information asymmetry and information uncertainty [J]. IEEE Transactions on Vehicular Technology, 2019, 68 (9): 8322-8335.], the authors proposed to collect fog vehicle information through the operator's recruitment contract. Based on this information, the classification of fog vehicles helps to identify their capabilities and characteristics in the network, and then more reasonably allocate tasks. Combined with the matching strategy based on pricing, this mechanism can efficiently handle task allocation in the network and ensure the optimal use of network resources, reducing the total delay of the network. In the literature [Zhou Yi. Research on distributed task offloading and communication resource allocation based on vehicle-mounted fog computing [D]. Chongqing University, 2020.], the authors believe that any fog vehicle can be used as a decision node, so each fog vehicle can collect vehicle information within the communication range. At the same time, a task offloading algorithm based on dynamic programming is proposed to improve resource utilization and minimize the total delay of task execution.

[0004] In the above-mentioned vehicle fog computing offloading research, the proposed VFC architecture solves the delay problem of the collection node to a certain extent, but it still has shortcomings. First, the three-layer VFC architecture will lead to high time and cost in the collection and transmission of vehicle information. Second, fog vehicles have high mobility as collection nodes, which leads to unstable communication signals and difficulty in achieving real-time updates of vehicle information. In contrast, mobile edge servers, as important infrastructure of the edge layer, can improve the stability of communication with vehicles by virtue of their fixed location. Based on these advantages, this paper designs a two-layer architecture with mobile edge servers as core nodes for collecting vehicle information and making task allocation decisions. In addition, the locally generated tasks in the system are heterogeneous in terms of features and QOS requirements. There may be tasks with similar data sizes but huge differences in deadlines. The existing computation offloading algorithm may make it impossible for some tasks to be completed within the deadline after being assigned, resulting in offloading failure. Therefore, this paper proposes a computation offloading algorithm based on task and vehicle characteristics, which can reduce the execution delay of tasks and improve the offloading success rate. Summary of the invention

[0005] The present invention aims to solve the above problems of the prior art. A computation offloading algorithm based on a weighted bipartite graph is proposed in a VFC scenario. The technical solution of the present invention is as follows:

[0006] A computation offloading algorithm in a vehicle fog computing scenario includes the following steps:

[0007] First, vehicles within the communication range of the roadside unit (RSU) establish a connection with the RSU through the long-term evolution communication technology. The vehicles actively report their location and computing resource information to the RSU at fixed time intervals to prepare for the subsequent execution of the computing offloading algorithm. Secondly, the task vehicle broadcasts a one-hop detection message through the dedicated short-range communication (DSRC) to obtain the fog candidate set. When the task vehicle sends an offloading request to the RSU, the obtained fog candidate set vehicle ID is sent to the RSU. Again, the RSU confirms the candidate vehicle of the task vehicle and executes the computing offloading algorithm based on the obtained vehicle information and task information. Finally, the RSU returns the computing offloading decision to the task vehicle, and the task vehicle assigns the task to the local or candidate vehicle for collaborative computing according to the returned offloading strategy.

[0008] Furthermore, the process of the RSU obtaining vehicle information specifically includes: within the communication range of the roadside unit (RSU), the vehicle establishes a stable wireless connection with the RSU through the long-term evolution (LTE) communication technology. After the connection is established, the vehicle will actively report its real-time location information and current computing resource status to the RSU at fixed time intervals in accordance with the preset protocol and time period. The reported location information is described based on a two-dimensional rectangular coordinate system established with the RSU as the origin. In addition, since the fog computing vehicle may allocate and execute computing tasks for multiple task vehicles at the same time, the computing resource information it reports is not only the total resource status of the vehicle, but the current remaining computing resources. By integrating these location information and remaining computing resource data, the RSU can dynamically analyze the task load and service coverage of each fog vehicle to obtain more reasonable allocation decisions.

[0009] Furthermore, in order to prevent the delay of computational offloading from being too large, this study only allows the task vehicle to obtain the candidate set through DSRC broadcasting one-hop detection information. The "one-hop" here means that the task vehicle only sends detection requests to neighboring vehicles within the direct communication range, and does not forward them through multiple hops through intermediate nodes. This mechanism effectively narrows the search range for computational task allocation and avoids the additional delay introduced by multi-hop communication, thereby improving the real-time performance of task allocation. This paper assumes that the number of generated tasks is greater than or equal to the number of fog vehicles, so some vehicles in the candidate set are not selected for offloading tasks. This paper uses the binary element y i,j surface Indicates whether the vehicle in the candidate set is selected. y i , j 1 indicates a vehicle j Mission vehicle i Selected.

[0010] Furthermore, the task vehicle sends an unloading request to the RSU, and the request information includes the identification (ID) of the task vehicle, the fog candidate set ID, and the relevant attributes of the task set, such as the unique identification of the task (task ID), data size, and deadline. By sending the unloading request information to the RSU, the RSU can fully understand the task requirements and the current computing resource environment, and formulate a reasonable unloading strategy accordingly. This process not only improves the efficiency of task processing, but also maximizes the use of distributed computing resources in a dynamic network environment, thereby achieving efficient coordination and scheduling optimization of computing tasks in the Internet of Vehicles.

[0011] Furthermore, RSU sorts vehicles and tasks according to the obtained vehicle information and task information. The basis for task sorting is data size, and the basis for vehicle sorting is vehicle performance. At the same time, this paper defines a performance index E jTo evaluate the performance of fog vehicle j in processing tasks, this performance indicator combines communication delay and computational delay, providing a comprehensive delay evaluation method for vehicle performance. j The smaller the value, the better the performance of the fog vehicle. j The formula is defined as follows:

[0012]

[0013] Among them, c i represents the computational complexity of the task generated by task vehicle i, B i,j Represents the channel bandwidth between task vehicle i and fog vehicle j. The vehicle periodically sends channel quality indication reports to the RSU, including information such as signal strength and signal-to-noise ratio. The RSU dynamically evaluates the channel status based on these reports, determines the maximum available bandwidth between different vehicles, and provides reliable data support for task offloading and collaborative computing. When i≠j, it means that the task of task vehicle i is offloaded to fog vehicle j for calculation, and the performance evaluation includes communication and calculation parts; when i=j, the task is directly calculated locally, and only the calculation delay part needs to be evaluated. Since vehicles with good performance are given priority for large task data, tasks k are sorted in ascending order according to task size. At the same time, since the smaller the delay for fog vehicles to process one bit of data, the better the performance, vehicle j is ranked according to E. j The task and vehicle are sorted in descending order. Finally, the sorting numbers of the tasks and vehicles are M k and E j .

[0014] Furthermore, the most important step in constructing a weighted bipartite graph is to weight the bipartite graph. After the task is assigned to the fog vehicle, the task execution delay may exceed the task deadline, which is not allowed by the task vehicle. In order to prevent such a situation, this study calculated the computational execution delay of task k unloaded to vehicle j in advance. The task execution delay includes communication delay, computational delay and result return delay. Since the return result is very small, the result return delay is ignored. Communication delay between task vehicle i and fog vehicle j The formula is defined as follows:

[0015]

[0016] Where D k represents the data size of task k, R i,j represents the transmission rate of task vehicle i and fog vehicle j.

[0017] Define a binary variable z j,kTo indicate whether task k is assigned to fog vehicle j, the v×a matrix Z they form describes the matching relationship between tasks and fog vehicles. Assuming that task k is generated by vehicle i, task k can be unloaded to fog vehicle j only when fog vehicle j is selected by task vehicle i and task k is generated by task vehicle i, that is, z j,k Satisfies the following formula:

[0018] j∈V i ,k∈A i ,z k,j ≤min{x i,k ,y i,j} (3)

[0019] Computational delay of task k offloading to vehicle j The formula is defined as follows:

[0020]

[0021] Finally, the total execution delay formula for unloading task k to vehicle j is as follows:

[0022]

[0023] The weighted formula is further defined as follows:

[0024]

[0025] where τ k is the deadline of task k. When task k is assigned to fog vehicle j for calculation, if task k cannot be completed within the deadline, its weight is assigned to 0, otherwise it is the sum of the sequence numbers of task k and vehicle j.

[0026] Furthermore, in order to add edges between tasks and vehicles and assign weights, the time complexity is O(va). This study uses binary search to reduce the time complexity of this step to O(logv). The specific steps are as follows: First, in the edge addition operation, it is necessary to check whether the condition (6) is met between each task and the fog vehicle. Since there are a large number of repeated judgment operations, in order to optimize the edge addition and weighting process, binary search is used to reduce repeated operations. Given that the vehicles have been sorted by performance, the binary search algorithm can be used to quickly locate the minimum serial number that meets the edge addition condition, that is, by comparing T k,j and τ k To control the movement of the left and right pointers of the binary search. Secondly, after finding the lower limit, the vehicles with serial numbers at and after the lower limit have better performance and meet the edge addition conditions by default, so the edge addition operation can be performed directly. Assume that the serial number returned by the binary search is seq l,k ,but

[0027] w(k,j)=M k +Lj ,L j ≥seq l,k (7)

[0028] Furthermore, the task allocation decision is obtained based on the weighted bipartite graph. First, the original problem is analyzed. Since task vehicle i generates multiple subtasks and assigns them to multiple fog vehicles for collaborative computing, the total execution delay of the task generated by task vehicle i is the maximum value of the execution delays of these subtasks. The purpose of this study is to optimize the total execution delay of the task generated by task vehicle i, that is, this study is a minimum-maximum problem. The optimization problem is expressed as:

[0029]

[0030] Constraint C1 means that the execution delay of each task cannot exceed the delay tolerance of the task. Constraint C2 means that each task is indivisible and can only be assigned to one fog vehicle. Each task is the basic unit of task assignment. Constraint C3 means that only fog vehicles in the fog candidate set of the task vehicle can help the task vehicle to coordinate calculations. Constraint C4 limits the computing power of fog vehicles and local. Due to the huge number of combinations of tasks and fog vehicles, the task assignment problem has extremely high computational complexity and is an NP-hard problem. This is because as the number of tasks and fog vehicles increases, the possible task assignment combinations grow exponentially, making the problem impossible to solve in polynomial time. The time complexity of using the brute force solution is O(n!), which is difficult to solve in a reasonable time in actual scenarios. Therefore, this paper introduces the tool of weighted bipartite graph to solve the optimization problem.

[0031] In order to minimize the total delay of task execution, this study is committed to improving the efficiency of resource utilization, and giving priority to vehicles with superior performance for collaborative computing for unloading large-scale tasks. Based on this idea, larger tasks tend to be assigned to fog vehicles with stronger computing capabilities, and tasks and fog vehicles are sorted according to specific rules, where large tasks and high-performance fog vehicles have higher serial numbers in the sorting. Therefore, the problem is abstracted as an optimization problem of a weighted bipartite graph. The optimization goal is transformed into finding the maximum weighted matching. After executing the Kuhn-Munkres (KM) algorithm, the matching matrix Z is obtained. The elements of the Z matrix are z j,k , when z j,k When the value is 1, it means that task k is offloaded to fog vehicle j for computation. This method not only achieves efficient task offloading, but also makes full use of the computing resources of fog computing vehicles, thereby significantly reducing the overall latency of task execution. At the same time, based on the abstraction of weighted bipartite graphs and the efficient solution of the KM algorithm, the robustness of the task allocation strategy in a dynamic environment is ensured, providing strong support for task scheduling in intelligent transportation systems.

[0032] The advantages and beneficial effects of the present invention are as follows:

[0033] 1. A two-layer VFC architecture was designed. This VFC architecture breaks the traditional concept of RSU as a computing node in the edge layer. RSU has powerful communication, computing and storage characteristics, and is used as the core node of the scheduling component to perform tasks. It not only collects information about vehicles within the coverage area as a collection node, but also executes the computing offloading algorithm as a decision node.

[0034] 2. A computation offloading algorithm based on weighted bipartite graph is proposed. Define a performance index E j To evaluate the performance of fog vehicle j in processing tasks, this performance indicator combines communication delay and computational delay, providing a comprehensive latency evaluation method for vehicle performance. After sorting according to vehicle performance and task size, a weighted bipartite graph is constructed, and then the KM algorithm is executed to calculate the allocation decision. This algorithm not only improves the computational offloading rate, but also further reduces the task execution latency. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] Figure 1 is the system scenario graph;

[0036] Figure 2 is an example graph of an abstract weighted bipartite graph;

[0037] Figure 3 This is a comparative experimental diagram of the unloading rate;

[0038] Figure 4 This is a comparison chart of task execution delay;

[0039] Figure 5 This is a comparative experimental diagram of resource utilization efficiency;

[0040] Figure 6 Attached is the abstract. DETAILED DESCRIPTION

[0041] The following will be combined with the accompanying drawings in the embodiments of the present invention to clearly and in detail describe the technical solutions in the embodiments of the present invention. The described embodiments are only part of the embodiments of the present invention.

[0042] The technical solution of the present invention is as follows:

[0043] In the intelligent transportation system integrating vehicle fog computing, in order to make full use of the computing resources of fog vehicles and achieve the optimal allocation of computing resources during task offloading, with the goal of minimizing the task execution delay, a computing offloading algorithm based on weighted bipartite graph is proposed. The algorithm uses the task vehicle and fog vehicle as the two vertex sets of the bipartite graph, where the edge weight represents the comprehensive cost of task offloading, including multiple factors such as computing resource usage cost, task transmission delay, and communication quality. By constructing such a bipartite graph model, the algorithm can dynamically obtain more reasonable offloading decisions according to environmental changes.

[0044] The computation offloading algorithm considering task execution delay proposed in the present invention comprises the following steps:

[0045] Step 1. First, within the communication range of the roadside unit (RSU), the vehicle establishes a stable wireless connection with the RSU through the long-term evolution (LTE) communication technology. After the connection is established, the vehicle will actively report its real-time location information and current computing resource status to the RSU at fixed time intervals according to the preset protocol and time period. Secondly, the task vehicle broadcasts a one-hop detection message through dedicated short-range communication (DSRC) to obtain the fog candidate set. When the task vehicle sends an unloading request to the RSU, the vehicle ID of the obtained fog candidate set is sent to the RSU. At the same time, the request information also includes the identification (ID) of the task vehicle and the relevant attributes of the task set, such as the unique identification of the task (task ID), data size and deadline, etc. The performance indicators of the vehicle are calculated based on this information.

[0046] Step 2: According to the size of the task and the performance of the vehicle, a weighted bipartite graph is constructed according to the edge weighting rule, and then the KM algorithm is executed to calculate the maximum weight matching. There are two collaborative computing methods, one is to calculate locally, and the other is to offload to other fog vehicles for computing. Because it is collaborative computing, the total execution delay of the task is the maximum value of the task delay of each fog vehicle.

[0047] In order to evaluate the performance of the algorithm proposed in this invention, the experiment used python3.6 to write the simulation code. In the scenario, the coverage range of RSU is 500*30m 2 ,This paper sets a task vehicle as a task generator. The vehicle randomly generates task sets and uses an RSU to simulate the entire task allocation process. In the simulation, the properties of the generated tasks and fog vehicles can be randomly generated by setting the number of generated tasks and fog vehicles. At the same time, the positions of fog vehicles are randomly generated. The position coordinates take RSU as the origin, the road as the horizontal axis, and the vertical axis perpendicular to the road as the vertical axis.

[0048] In order to verify the rationality of the task allocation algorithm KM_TA proposed in this paper, this paper ran 100 simulations and compared it with three algorithms in different performance dimensions. (1) Allocating tasks by the distance between vehicles: tasks with large amounts of data tend to be unloaded to closer fog vehicles, so tasks from large to small are unloaded to the vehicle closest to the task vehicle, recorded as the "CS" scheme. (2) Allocating tasks by the computing resources of fog vehicles: tasks with large amounts of data tend to be unloaded to the fog vehicle with the strongest computing power, recorded as the "GS" scheme. (3) Allocating tasks by preference matrix: a formula is designed to calculate the preference values ​​of tasks and fog vehicles. From large to small tasks, fog vehicles with the largest preference values ​​are selected for matching, recorded as the "TARA" scheme, which is the reference [Wu X, Zhao S, Deng H. Joint task assignment and resource allocation in VFC based on mobility prediction information [J]. Computer Communications, 2023, 205: 24-34.]

[0049] Figure 3 The figure shows the number of successful task offloading for different schemes. It can be seen from the figure that the algorithm proposed in this paper is the best in terms of the performance dimension of the offloading success rate. Sub-figure (a) shows the relationship between the number of vehicles and the number of successful task offloading. In this paper, the number of unloading tasks is fixed at 15. As the number of fog vehicles increases, the number of tasks that are successfully offloaded for all schemes also increases. At the same time, the KM_TA scheme requires the least number of fog vehicles to successfully offload all tasks. This is because when the number of fog vehicles gradually increases, the user's choice space for fog vehicles is significantly expanded. The algorithm in this paper can effectively guide users to offload tasks to fog vehicles that can complete the calculation within the deadline, thereby improving the success rate of task offloading. As the number of fog vehicles further increases, users can obtain sufficient computing resources and finally achieve successful offloading of all tasks, fully ensuring the completion quality of the computing tasks. Sub-figure (b) shows the relationship between the number of offloaded tasks and the number of successful offloading. Under the condition that the number of fog vehicles is fixed at 50, as the number of generated tasks gradually increases, the number of successful task offloading also increases. However, when the number of offloaded tasks approaches the total number of fog vehicles, the effect of each algorithm on improving the offloading success rate gradually weakens. This is because, as the number of tasks increases, the number of successfully unloaded tasks increases, but the fog vehicle resources available for users to choose become limited, making it difficult to further optimize the algorithm performance. Since the KM algorithm can find more matches by adjusting the top mark, the KM_TA scheme can improve the task unloading rate after introducing the KM algorithm.

[0050] Figure 4The execution delays of the four algorithms under different system loads were compared, that is, the advantages and disadvantages of the algorithms were observed for different tasks or different vehicles. Figure 4 It can be seen that the task execution delay of the task offloading scheme proposed in this paper is the smallest. Figure (a) shows the relationship between the number of vehicles and the delay. The number of fixed tasks is 15. It can be seen that the performance of the GS scheme is the worst, and the difference between the TARA and CS schemes is not much. At the same time, when the number of vehicles is sufficient, the optimization performance level of all algorithms tends to be stable. When the number of vehicles is large compared to the number of tasks, the user has sufficient computing resources. If the number of vehicles is continuously increased, the user cannot use the excess computing resources. Therefore, the delay optimization performance of the five algorithms tends to be stable. Sub-figure (b) shows the relationship between the number of offloaded tasks and the delay performance. The number of fixed vehicles is 50, which ensures that the user has abundant computing resources. As the number of tasks increases, the overall delay increases. When the number of tasks is small, the user has sufficient computing resources, and the allocation algorithm can have more matching options, so the optimization degree of each algorithm is more different. At the same time, as the number of tasks continues to increase, the gap between the number of vehicles and the number of tasks gradually narrows, and the flexibility of user tasks in vehicle selection gradually decreases. Therefore, as the number of tasks increases, the optimization effect of the algorithm proposed in this paper shows a trend of gradually weakening due to the reduction of the optimization space.

[0051] Since the distance between the vehicle and the task vehicle and the idle computing resources of the vehicle will affect the execution delay of the collaborative computing, this section simulates and observes the robustness of each algorithm under different V2V communication distances and vehicle computing power. In order to compare the robustness of the algorithms, this section sets the same tasks and fog vehicle attributes to ensure that the resource space selected by the algorithms is the same. Figure 5It can be seen that the algorithm in this paper performs well in different scenarios, and its task execution delay is the smallest. Figure (a) shows the impact of the maximum computing power of fog vehicles on the task execution delay. As the maximum computing power of fog vehicles increases, the total execution delay of the task decreases, and the execution delay of the KM_TA scheme is the smallest. Since the GS scheme only uses computing power as the evaluation criterion for the performance of fog vehicles and does not consider the impact of communication distance on execution delay, the performance of this scheme is the worst. Comparing the CS scheme and the GS scheme, it can be seen that the impact of communication distance on task execution delay is more significant than computing power. Therefore, it is particularly important to include communication distance in the evaluation of fog vehicle performance. When the maximum computing power of the fog vehicle is greater than 6GHz, the trend of reducing the total delay of task execution slows down, because the computing requirements of the task are fixed. When computing resources are saturated, the optimization effect of further increasing computing power on latency has weakened, and the main factor determining latency has shifted to the transmission stage of the task. Figure (b) shows the impact of V2V communication range on task execution latency. As the V2V communication range increases, the task execution latency also increases, and the execution latency of the KM_TA scheme is the smallest. When the V2V communication distance is less than 30 meters, the GS scheme is second only to the scheme proposed in this paper. As the communication range of fog vehicles increases, the CS scheme becomes the worst scheme. Figure 3 and Figure 4 The V2V communication distance is 50m, and the GS solution performs the worst, which is consistent with the simulation in this section. As the V2V communication range increases, the efficient use of communication resources becomes the most critical issue. Therefore, the GS solution, which is most concerned about vehicle computing resources, becomes the worst solution, and the CS solution surpasses the GS solution. Since the algorithm in this paper considers the impact of communication distance and computing power on latency when defining vehicle performance, the resource utilization efficiency is optimal in different scenarios.

[0052] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0053] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.

[0054] It should also be noted that the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of more restrictions, the elements defined by the sentence "comprises a ..." do not exclude the existence of other identical elements in the process, method, commodity or device including the elements.

[0055] The above embodiments should be understood to be only used to illustrate the present invention and not to limit the protection scope of the present invention. After reading the contents of the present invention, technicians can make various changes or modifications to the present invention, and these equivalent changes and modifications also fall within the scope defined by the claims of the present invention.

Claims

1. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing, characterized in that: The following steps are involved:

101. Collecting vehicle location and idle computing resource information on the roadside unit (RSU) side to build a vehicle performance evaluation model; 102. Based on the data information obtained in step 101, the evaluation index definition of vehicle performance is obtained by combining the calculation unloading process and the delay calculation formula; 103. According to the performance index obtained in step 102, the RSU is sorted into a candidate vehicle set for the task vehicle. Then a weighted bipartite graph is constructed; 104. Sort the vehicles according to the vehicle performance index of step 103, and then sort them according to the task size. The weight of the weighted bipartite graph is defined by the sorting sequence number, and the Kuhn-Munkres algorithm is executed on the weighted bipartite graph to obtain the task allocation decision.

2. According to a computation offloading algorithm based on weighted bipartite graph in vehicle fog computing described in claim 1, it is characterized in that: The vehicle performance evaluation model construction specifically includes:

201. RSU communicates with vehicles within the coverage area through Long Term Evolution (LTE) to receive the transmitted data and transmit the collected data to the nearby Mobile Edge Server (MES); 202. The MES calculates the performance index of the vehicle based on the data obtained in step 201 and the traffic network topology.

3. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 2, characterized in that: The data collection process described is mainly achieved through two communication methods: between vehicles and between vehicles and infrastructure:

301. The mission vehicle broadcasts a one-hop detection message through dedicated short-range communication to obtain a fog candidate set; 302. The task vehicle sends a task offloading request to the RSU via LTE, and the request information includes the task size, the delay tolerance of the task, the computational complexity of the task, and the ID of the candidate vehicle; 303. The RSU sends the task attributes and candidate vehicle set obtained in step 302 to the nearby MES. After the MES executes the calculation unloading algorithm, it transmits the unloading decision to the task vehicle through the V2V link.

4. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 1, characterized in that: The parameter definitions described in constructing a weighted bipartite graph based on the collected data specifically include: Vehicle Performance Index E j , the task of the task vehicle is offloaded to the candidate set vehicle for calculation. Its latency will be affected by the communication distance and the idle computing resources of the candidate set vehicles. Therefore, a performance indicator is defined from the perspective of latency. The closer the vehicle is to the task vehicle and the stronger the computing power, the better the performance. Otherwise, the worse the performance. The weight w of the edge connecting task k and vehicle j k,j , tasks and candidate vehicles need to be sorted. Tasks are sorted according to their size. The larger the data volume, the larger the task number. Vehicle performance indicators are sorted. The smaller the performance indicator, the better the vehicle performance and the larger the vehicle number. Add edge lower limit sequence number seq l,k Only after task k is unloaded to vehicle j, the task can be completed within the delay tolerance, and task k and vehicle j can meet the weighted condition in the abstract bipartite graph. Since the vehicles have been sorted according to performance indicators, the binary search algorithm can be used to quickly locate the minimum sequence number that meets the edge addition condition. After finding the lower limit, the vehicles with sequence numbers at and after the lower limit have better performance and meet the edge addition condition by default, so the edge addition operation can be performed directly.

5. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 4, characterized in that: The calculation performance index, edge weight and edge lower limit sequence number specifically include: Vehicle performance indicators: Among them, E j represents the performance index of the task vehicle j at this time, B i,j represents the channel bandwidth between mission vehicle i and fog vehicle j, d i,j represents the distance between task vehicle i and fog vehicle j, which is obtained from the positions of the task vehicle and fog vehicle, p represents the transmission power of the vehicle, h represents the channel gain, N0 represents the noise power spectral density, and defines a variable c i represents the computational complexity of the task, which is the number of CPU cycles consumed per bit of task k, f j represents the computing power of fog vehicle j; when i≠j, it means that the task of task vehicle i is offloaded to fog vehicle j for calculation, and the performance evaluation includes communication and calculation parts; when i=j, the task is directly calculated locally, and only the calculation delay part needs to be evaluated; The weight of the edge between bipartite graph task k and vehicle j is: When vehicle j can complete task k within the delay tolerance, the weight of the edge between vehicle j and task k is the sum of their serial numbers, otherwise it is 0. The serial number of vehicle j is obtained by sorting in descending order according to the performance index, and the serial number of task k is obtained by sorting in ascending order according to the data size. Since the binary search method can be used to search for the lower limit serial number seq of task k l,k ,therefore 6. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 5, characterized in that: The uninstallation strategy specifically includes: x i,k To indicate whether task k is generated by i, x i,k When y is 1, it means that task k is generated by task vehicle i. The number of vehicles and tasks in the candidate set is different, so some vehicles in the candidate set are not selected for unloading tasks. This paper uses the binary element y i,j Indicates whether the vehicle in the candidate set is selected, y i,j 1 means vehicle j is selected by task vehicle i. In addition, a binary variable z is defined j,k To indicate whether task k is assigned to fog vehicle j for calculation. Assuming that task k is generated by vehicle i, task k can be unloaded to fog vehicle j only when fog vehicle j is selected by task vehicle i and task k is generated by task vehicle i, that is, z j,k Satisfies the following formula: The computing resources of each vehicle are limited, so the computing offloading algorithm is used to fully utilize the computing resources of the vehicle to reduce the task execution delay. The computing resources of each vehicle cannot exceed the maximum computing resource limit, that is: 0≤f j ≤f j,max (5) 7. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 6, characterized in that: The task vehicle generates a tasks, and the execution time of each task unloaded to vehicle j includes the transmission delay Calculating latency And constant time overhead l. Specifically including: Since the task vehicle needs to broadcast a one-hop detection message through dedicated short-range communication to obtain the fog candidate set, there is an additional constant time overhead for executing the task, defined as l, which is the round-trip time (RTT) between the task vehicle and the fog vehicle. Because l is very short, this paper does not consider its size. The total execution delay of task k is as follows: The tasks generated by the task vehicle are collaboratively calculated by the user's local and fog candidate set vehicles, so the total service delay is the maximum value of the execution delay of all tasks generated by the user. The task execution delay of task vehicle i is defined as T i , the calculation formula is as follows: Shannon's theorem shows that the link transmission rate R between the selected fog vehicle j and the task vehicle i is i,j , the formula is as follows: Where α is the path loss coefficient, d i,j represents the distance between task vehicle i and fog vehicle j, which is obtained from the positions of task vehicle and fog vehicle, p represents the transmission power of the vehicle, h represents the channel gain, N0 represents the noise power spectral density, and D k is the data size of task k. Finally, we get the transmission delay of task vehicle i transmitting task k to fog vehicle j: The formula is as follows: The computational delay of a task is determined by the computational effort and complexity of the task. Define a variable c k represents the computational complexity of the task, which is the number of CPU cycles consumed per bit of task k, f j represents the computing power of fog vehicle j, that is, the number of CPU cycles executed per second. The computational latency of fog vehicle j selected by task k is obtained by the following formula:

8. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 1, characterized in that: The optimization goal of this paper is the task execution delay, that is, T i . Since task vehicle i generates multiple subtasks and assigns them to multiple fog vehicles for collaborative computing, the total delay of task execution of the task vehicle is the maximum value of the execution delay of the generated task set. This paper aims to minimize the total execution delay of the task generated by the task vehicle. The problem of this paper is transformed into a minimum-maximum problem. In order to minimize the total task delay, it is necessary to design an algorithm that can flexibly make task allocation decisions based on the topological structure of the traffic network. The elements of the Z matrix are z j,k , when z j,k When the value is 1, it means that task k is offloaded to fog vehicle j for calculation. The optimization problem is expressed as: Constraint C1 indicates that the execution delay of each task cannot exceed the delay tolerance of the task, where τ k represents the delay tolerance of task k. Constraint C2 indicates that each task is indivisible and can only be assigned to one fog vehicle. Each task is the basic unit of task assignment. Constraint C3 indicates that only fog vehicles in the fog candidate set of task vehicles can help task vehicles with collaborative computing. Constraint C4 limits the computing power of fog vehicles and local.

9. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 5, characterized in that: There are a lot of redundant operations in the edge addition operation, and the binary search algorithm is used to reduce the redundant operations. The details are as follows: Since the vehicles are already sorted by performance, we can use the binary search algorithm to quickly locate the minimum sequence number that meets the edge addition condition. After finding the lower limit, the vehicles with sequence numbers at and after the lower limit have better performance and meet the edge addition condition by default, so we can directly perform the edge addition operation. Assume that the sequence number returned by the binary search is seq l,k ,but:

10. A computation offloading algorithm based on weighted bipartite graph in vehicle fog computing according to claim 5, characterized in that: The time complexity of using is O(n 3 ) solves the NP-hard problem. The maximum weighted match obtained by the Kuhn-Munkres algorithm is the final allocation decision. According to the solved matching relationship, the task of the task vehicle is offloaded locally or to other fog vehicles for collaborative calculation.

Images