Centralized dependency task scheduling and offloading optimization algorithm for vehicle-to-edge network

Abstract

This invention provides a centralized dependency task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks, relating to the field of V2X edge computing technology. This algorithm includes the following: 1) a VEC-based vehicle-assisted dependency task offloading architecture; 2) consistency constraints between the task model and subtask offloading positions; 3) system model and problem formalization; 4) the LD-BGMH algorithm; and 5) simulation results. This invention designs a centralized two-layer scheduling and offloading architecture for edge server decision-making and idle vehicle assistance. This architecture achieves centralized computing resource management based on task dependencies, solving the difficulties in global state perception and low accuracy in vehicle-based distributed decision-making schemes, as well as the game-theoretic dilemma when using vehicle resources, and reducing the complexity of dependency task execution and resource coordination management between different nodes.

Description

Technical Field

[0001] This invention relates to the field of vehicle-to-everything (V2X) edge computing technology, specifically to a centralized dependency-based task scheduling and offloading optimization algorithm for V2X edge networks. Background Technology

[0002] Vehicular edge computing (VEC) can overcome the resource limitations of vehicles and avoid the long transmission latency of cloud computing, and has been considered a promising computing paradigm. However, in most VEC system task offloading studies, vehicle tasks are usually simply divided into two idealized task models: indivisible tasks and arbitrarily divisible tasks. While this avoids the impact of subtask dependencies on offloading strategies, it severely reduces the application value of offloading strategies in real-world scenarios.

[0003] In practical applications, vehicle tasks are divided into multiple subtasks based on the processing flow, and these subtasks are processed strictly according to the chronological order of the processing flow. Therefore, there are clear dependencies between the subtasks. For example... Figure 1 The in-vehicle augmented reality holographic navigation service shown allows the driver to input voice commands. Upon receiving the commands, the application identifies the target based on video data, tracks the target, and performs corresponding analysis and processing. The resulting data is then mapped to generate real-time navigation guidance, which is projected onto the road ahead of the driver for more accurate guidance. This demonstrates a strict sequential and parallel relationship between the vehicle's sub-task modules. Meanwhile, due to the intensive demand for edge computing services in urban scenarios and the insufficient edge computing infrastructure in suburban scenarios, edge computing resources are limited, further increasing the difficulty of scheduling and offloading dependent tasks. Summary of the Invention

[0004] (a) Technical problems to be solved To address the shortcomings of existing technologies, this invention provides a centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks, which solves the defects and deficiencies in existing technologies.

[0005] (II) Technical Solution To achieve the above objectives, this invention provides the following technical solution: a centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks, comprising the following: 1) VEC-based Dependency Offloading Architecture for Vehicle Assistance a. VEC architecture; 2) Consistency constraint between task model and subtask unloading location a. DAG model; b. Consistency constraints on subtask unloading location; 3) System Model and Problem Formalization a. Communication model; b. Computational model; c. Task latency and energy consumption model; d. Formalize the problem; 4) LD-BGMH Algorithm a. Resource allocation strategy; b. Subtask dynamic sorting algorithm; c. Dependency-based task unloading algorithm; 5) Simulation results.

[0006] Preferably, the VEC architecture includes an edge computing service unit within the RSU coverage area, and the mission vehicle is... express, Indicates the first task generated One vehicle, the available vehicle is... This indicates that the number of vehicles on the mission is... k The number of available vehicles is x The processing units in the edge server consist of a set express, For the first in the edge server Each processing unit generates scalable, dependent tasks from task vehicles. Under resource constraints, the resulting subtasks can be offloaded to edge servers and idle vehicles. V Part of the subtasks in 2 are processed at the edge, while another part is assisted in being unloaded to idle vehicles.

[0007] Preferably, the consistency constraint between the task model and the subtask unloading location is as follows: a. DAG model; To accurately describe the dependencies between subtasks in a dependent task, a directed acyclic graph (DAG) is used to model the task. DAGs are typically represented by binary tuples. This indicates that, for a single dependency task V The corresponding DAG model is given by definition; b. Consistency constraints on subtask unloading location; For a maximum of being divisible into Dependent tasks V Its uninstallation strategy needs to be implemented on the vehicle's local machine and on the edge server. m Each processing unit and x When choosing a combination of execution locations from three types of idle vehicles, without considering the partitioning and enumeration of dependent tasks, the size of its decision space is... for , s It grows exponentially, making optimization extremely complex; Under the Subtask Offload Location Consistency (SOLC) constraint, regardless of s What value should be taken? V It can be divided into two parts for execution at most. These two parts can be either unloaded to the same location, in which case the entire task is equivalent to not being split and executed, or one part can be processed on the edge server and the other part can be processed on the vehicle.

[0008] Preferably, the system model and problem are formalized as follows: a. Communication model The system employs a frequency division multiple access (FDMA) mechanism, where uplink bandwidth is evenly distributed based on the number of vehicles connected to the same RSU. Because different vehicles occupy orthogonal frequency bands for data transmission, interference between vehicles within the same RSU coverage area is effectively avoided. The uplink data transfer rate to the edge server is: (1) In the formula For the total uplink bandwidth, ( x+k () represents the total number of vehicles within the RSU coverage area. For the vehicle's transmission power, For vehicles Channel gain of edge servers Noise power; The transmission power of the edge server is denoted as Similarly, the connection between the edge server and the vehicle can be derived. downlink data transmission rate ; The The data volume of each subtask is denoted as . The vehicle was obtained subtasks Transmission latency to the edge server: (2) Similarly, it can be concluded that the edge server will handle subtasks. Assisted unloading to idle vehicles The delay is denoted as ; The energy consumption of uploading subtasks to the edge server depends on the vehicle's transmission power and the data transmission latency. The transmission energy consumption is expressed as: (3) Similarly, the edge server can be directed to idle vehicles. Transmission subtask Energy consumption: (4) Subtask The amount of data resulting from the calculation is denoted as . Therefore, we can conclude that Energy consumption for transmitting calculation results from idle vehicles to the edge server: (5) In the formula For idle vehicles Similarly, the uplink data transfer rate to the edge server can be derived. The calculation results are transmitted from the edge server to the energy consumption of the task vehicle and the idle vehicle, respectively denoted as... and ; Export task result feedback specifically refers to the process by which the edge server feeds back the export task processing result to the corresponding task vehicle; the amount of subtask result data is much smaller than the amount of subtask data, so the latency and energy consumption of result feedback are negligible. b. Computational Model Vehicle calculation frequency is denoted as f c The computation frequency of a single processing unit on an edge server is denoted as... f mec Then subtask The computational latency at the vehicle end is: (6) Therefore, the subtask is derived. Energy consumption calculation at the vehicle end: (7) In the formula For vehicles at a calculated frequency of f c Calculate the power corresponding to the task in real time; Subtask In the processing unit The computational latency and energy consumption are shown below: (8) (9) In the formula For a single processing unit of an edge server at a computing frequency of f mec Calculate the power corresponding to the task in real time; c. Task latency and energy consumption model Subtasks of a dependency-based task have strict dependencies on each other. When subtasks are offloaded to different edge servers for execution, this can affect non-entry point tasks. Its execution requires the following prerequisite: only when all first-level precursor subtasks are executed. The calculation is completed, and the corresponding result data is transmitted to... The subtask can only be started and executed after it is located in the processing unit. In the processing unit The start time of execution can be defined as: (10) In the formula This indicates that, without considering dependency constraints, the processing unit Able to provide The earliest moment when computing services were provided, express The completion time of the neutron mission express The computation results of the neutron task are transmitted to The transmission latency at the current location is affected by the consistency constraint at the subtask unloading location. It exists only in one case, namely and All subtasks on the given path are processed on the vehicle side, while the remaining subtasks are processed on the edge server. or ,in and They represent The latency of transmitting the calculation results from the edge server to the task vehicle and the idle vehicle; For subtasks In the processing unit The calculation completion time is represented as follows: (11) For a dependent task V If both its entry and exit tasks are in the processing unit Execution can be performed to determine when it begins execution. Thus, its completion time is obtained. For the first-level successor subtask of the entry task The completion time can be obtained from formulas (10) and (11), and so on until the exit task. , for The completion time is also the completion time of this dependent task; Will V The time of its generation is recorded as ,but V Waiting delay and completion delay As shown in equations (12) and (13) respectively: (12) (13) For a dependent task V If its If the idle vehicle completes the task, then V The total latency should be On top of that, data is transmitted to the edge server. Transmission delay of calculation results If its If completed locally on the vehicle or on an edge server, then V The total delay is ,use express V The total delay is then: (14) V Total energy consumption includes: the computational energy consumption of subtasks locally. Energy consumption of subtasks offloading to edge servers The computational energy consumption of subtasks on edge servers Energy consumption of idle vehicles assisting in unloading The subtask calculates the energy consumption of idle vehicles. Energy consumption for transmitting subtask calculation results between vehicles and edge servers ,use express V The total energy consumption is then: (15) in, i This refers to a subtask computed locally. j This refers to a subtask computed on an edge server. k This indicates a subtask computed on an idle vehicle. d. Problem formalization Different unloading methods and processing orders for subtasks will affect the overall completion latency of dependent tasks. For mission vehicles The set of subtask unloading decisions, Indicates the mission vehicle subtasks Process locally. express In the processing unit deal with, express idle vehicles Processing, defining For mission vehicles The set of subtask priority weights, for ,express subtasks and Executed in the same place, and Prior to implement; Will handle dependency tasks V Expenses Defined as the weighted sum of latency and energy consumption, then: (16) in As a weighting factor; System overhead is defined as the average of the total overhead of all task vehicles in the system for completing all dependent tasks they generate; if the system k A total of [number] vehicles generated R A dependent task, using V r To differentiate between different dependency tasks, the optimization problem can be formalized as: (17) This is a logic constraint for the execution of subtasks of a dependent task, indicating that the start time of any subtask cannot be earlier than the completion time of its first-level predecessor subtask. As constrained by time delay and energy consumption weighting factors, As a constraint on the total task delay, and Consistency constraints for the unloading location of subtasks. Indicates when subtask When processing locally, They should be processed locally together. Indicates when subtask When handling idle vehicles Should be with Processed in the same idle vehicle.

[0009] Preferably, the LD-BGMH algorithm includes three core mechanisms: resource allocation constraints, dynamic subtask sorting, and dependent task unloading matching. First, it formulates an allocation strategy for processing units to ensure the fairness of resource allocation in multi-user scenarios. Second, it constructs a dynamic subtask sorting strategy based on critical paths and dependency strength to clarify the execution priority of subtasks within the same processing unit, effectively reducing the total task latency. Finally, under the constraint of consistency in subtask unloading positions, it deeply integrates the traditional bipartite graph matching-Hungarian algorithm with a layer-by-layer greedy partitioning algorithm based on DAG hierarchy to form a task unloading solution suitable for dependent constraints.

[0010] Preferably, the simulation results are compared horizontally with the following five algorithms to prove the effectiveness of the proposed algorithm. The comparison algorithms are as follows: (a) Local processing: All dependent tasks are processed locally by the task vehicle; (b) Edge server offloading: All dependent tasks are offloaded to the edge server. This algorithm allows the edge server to provide multiple processing units for a group of dependent tasks for the same vehicle. (c) Random offloading: Randomly decides the execution location of tasks that depend on other tasks, which can be processed locally or offloaded to edge servers and idle vehicles; (d) Greedy Algorithm: When unloading dependent tasks, a greedy strategy is used to match resources. It traverses all available computing resources and allocates the resources that minimize the current overhead to each subtask, only pursuing the local immediate optimal unloading decision. (e) Traditional bipartite graph matching-Hungarian algorithm: The DAG of the dependent task is randomly and legally divided into two sub-task sets to construct the bipartite graph task set and perform matching solution. Compared with the proposed algorithm, the overall matching and layer-by-layer greedy partitioning are removed.

[0011] (III) Beneficial Effects This invention provides a centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks. It offers the following advantages: 1. This invention designs a centralized two-layer scheduling and offloading architecture with edge server decision-making and idle vehicle assistance. This architecture realizes centralized computing resource management based on task dependencies, solving the problems of difficulty in global state perception and low accuracy in vehicle-based distributed decision-making schemes, as well as the game dilemma when using vehicle resources, and reducing the complexity of dependent task execution and resource coordination management between different nodes.

[0012] 2. This invention designs a dynamic subtask sorting algorithm based on critical path and dependency strength. This algorithm solves the resource waste problem caused by the pre-fixed execution order of subtasks in existing priority sorting algorithms, which results in "high-priority subtasks waiting for predecessors and low-priority ready subtasks being unable to execute." This effectively improves system resource utilization and reduces the overall task completion latency.

[0013] 3. This invention designs a two-layer matching strategy of subtask unloading location consistency constraint and task unloading, and proposes the LD-BGMH algorithm in conjunction with the subtask dynamic sorting mechanism. This algorithm effectively shortens the startup waiting latency when subtasks are executed across computing nodes, and achieves synergistic optimization of task processing efficiency and resource utilization.

[0014] 4. The LD-BGMH algorithm of this invention can efficiently utilize vehicle-side collaborative resources under both high and low load conditions, significantly reducing system overhead while ensuring task completion rate, and its overall performance is significantly better than the five comparative algorithms. Attached Figure Description

[0015] Figure 1 Example diagram of a vehicle-mounted augmented reality holographic navigation-dependent task; Figure 2 A schematic diagram of a resource-constrained VEC application scenario; Figure 3 A schematic diagram of a centralized two-layer scheduling and offloading architecture; Figure 4 A schematic diagram of a DAG model for vehicle-mounted augmented reality holographic navigation-dependent tasks; Figure 5 A diagram illustrating the dynamic sorting process for subtasks; Figure 6 Example diagram of matching subtasks with resources; Figure 7 A schematic diagram illustrating the impact of the subtask sorting algorithm on the LD-BGMH algorithm; Figure 8 A schematic diagram illustrating the system overhead of different algorithms under different numbers of tasks; Figure 9 This diagram illustrates the resource utilization of different algorithms under varying numbers of tasks. Figure 10 A diagram illustrating the task completion rate of different algorithms under different task quantities; Figure 11 A comparison chart of response latency for different task-dependent structures. Detailed Implementation

[0016] The technical solutions of 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.

[0017] Example: like Figure 1-11 As shown, this embodiment of the invention provides a centralized dependency task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks, including the following: 1) VEC-based vehicle assistance dependency task offloading architecture.

[0018] a. VEC architecture; Without considering the collaborative operation of multiple roadside units (RSUs), Figure 2 This paper presents a typical resource-constrained VEC application scenario. The figure shows an edge computing service unit within the RSU coverage area, and the task vehicle is... express, Indicates the first task generated One vehicle, the available vehicle is... This indicates that the number of vehicles on the mission is... k The number of available vehicles is x The processing units in the edge server consist of a set express, For the first in the edge server Each processing unit generates scalable, dependent tasks. Under resource constraints, these subtasks can be offloaded to edge servers and idle vehicles. Figure 2 Medium-dependency tasks V Part of the subtasks in 2 are processed at the edge, while another part is assisted in being unloaded to idle vehicles.

[0019] For the offloading computation of dependency tasks in resource-constrained scenarios, this invention designs a centralized two-layer scheduling and offloading architecture with edge server decision-making and idle vehicle assistance. For example... Figure 3 As shown, the architecture consists of task vehicles, idle vehicles, and edge servers. The vehicle side mainly consists of a task parsing unit, a vehicle controller, a resource management module, a communication unit, and a data processing unit (including a computing module, a transmission module, a waiting queue, and an executable subtask pool). Among them, the resource management module is responsible for monitoring and uploading the real-time status of vehicle resources. The edge server mainly consists of a software-defined networking (SDN)-based decision module, an MEC controller, an MEC buffer, a data processing unit, and a communication unit. Among them, the SDN-based decision module is responsible for synchronizing the vehicle resource status and making offloading decisions.

[0020] Compared to traditional task offloading architectures based on vehicle-distributed decision-making, the proposed centralized two-layer scheduling and offloading architecture uses an edge server as a unified decision-making center. It does not rely on direct communication between vehicles; instead, the edge server centrally handles offloading decisions, subtask forwarding, and result feedback. The advantages of this design are mainly reflected in two aspects. First, the SDN central decision-making module in the edge server can centrally configure scheduling and offloading strategies by combining task dependencies, edge processing unit load, and the available resource status of idle vehicles. This enables collaborative management of the computing resources of the edge server and idle vehicles, alleviating the problems of insufficient global state awareness and resource allocation bias that exist when vehicle nodes make distributed decisions based only on local information. Second, since vehicles do not directly interact with subtask data, the offloading process does not require additional characterization of inter-vehicle communication links and subtask transmission relationships, thus simplifying node interaction relationships during the execution of dependent tasks and reducing the complexity of resource coordination and management between different computing nodes.

[0021] A typical dependency-based task offloading computation process usually includes four stages: task parsing, subtask offloading, subtask computation, and task result feedback. First, the task vehicle generates the dependency task and breaks it down into multiple subtasks using the task parsing unit, while simultaneously identifying and establishing dependencies between these subtasks. Then, the task vehicle initiates an offloading request to the edge server. The SDN-based decision module generates an offloading decision, which is then fed back to the task vehicle by the MEC controller via the communication unit. For subtasks requiring offloading, the data transmission module sends them to the MEC buffer, while the remaining subtasks enter the vehicle's local waiting queue. Subtasks in the waiting queue that meet the execution conditions enter the executable subtask pool and are processed by the local computation module according to their priority. Considering the limited resources of the edge server, some subtasks can be further assisted in offloading to idle vehicles for execution. After the task is completed, the computation results are uniformly fed back to the task vehicle by the edge server's data processing unit.

[0022] 2) Consistency constraint between task model and subtask unloading location a. DAG model; To accurately describe the dependencies between subtasks in a dependency-based task, this invention uses a Directed Acyclic Graph (DAG) to model the task. A DAG typically uses pairs of tuples... This indicates that, for a single dependency task V The corresponding DAG model is given by the following definition: Definition 1: V All subtasks are a set of nodes , among which, element v n Indicates task V The split-off n Sub-tasks; Definition 2: V The dependencies of all subtasks are a set of directed edges. , among which, element It is a line from v i point to v j A directed edge represents v j Directly dependent on v i , <i,j> It is an ordered pair of subtasks, that is v i yes v j The first-level precursor sub-task; Definition 3: ; Figure 4 Given a vehicle-mounted augmented reality holographic navigation-dependent task V DAG model, set of subtasks Subtask dependency set ,exist In the middle, sub-task sequence This describes the dependencies between a set of subtasks, where inset curly braces indicate... v 2 and v 3. They are mutually independent. v 4 and v 5 are also independent of each other, but have the same predecessor sub-task or the same successor sub-task; Definition 4: Subtask v i All predecessor subtasks are ordered sets , Figure 4 middle, ,in, v 4 and v 5 are respectively v A 6-level front-wheel drive is represented as , v 2 and v 3 are respectively v The 6 is a level 2 front-wheel drive, represented as And so on; Definition 5: Subtask v i All successor subtasks are ordered sets , Figure 4 middle, ,in, v 7 is v The first-level successor of 6 is represented as , v 8 and v 9 is v The second-level successor of 6 is represented as And so on; Definition 6: The entrance is for all those who satisfy subtasks v i , The export is all that meets subtasks v j .

[0023] If multiple entry or exit tasks exist, they are connected to the same pseudo-entry or pseudo-exit task. This has zero computational cost and no communication overhead with other adjacent subtasks. The only entry point task is recorded as ventry The only export task is recorded as v exit .

[0024] b. Subtask unloading location consistency constraints For a maximum of being divisible into Dependent tasks V Its uninstallation strategy needs to be implemented on the vehicle's local machine and on the edge server. m Each processing unit and x When choosing a combination of execution locations from three types of idle vehicles, without considering the partitioning and enumeration of dependent tasks, the size of its decision space is... for , s It grows exponentially, making optimization extremely complex; To compress the decision space, this invention proposes a Subtask Offload Location Consistency (SOLC) constraint: if a subtask is scheduled to be executed on a vehicle, then that subtask and all its successor subtasks must also be executed on the same vehicle. Figure 4 For example, if the subtask In vehicle processing, an ordered set is used. All subtasks should be processed in the same vehicle. Under SOLC constraints, regardless of s What value should be taken? V It can be divided into two parts for execution at most. These two parts can be either unloaded to the same location, in which case the entire task is equivalent to not being split and executed, or one part can be processed on the edge server and the other part can be processed on the vehicle.

[0025] This constraint, by ensuring that the execution positions of some subtasks are consistent, not only eliminates suboptimal strategies where the overhead of transmitting subtask results accounts for an excessively high proportion, but also... Significantly compressed to This significantly reduces the complexity of solving the unloading decision while ensuring the continuity and efficiency of subtask execution.

[0026] remember for V It can be divided into at most 10 parts s The cumulative number of partition schemes under the condition of [number of partitions] To account for the size of the decision space after partitioning and enumeration, To consider the size of the decision space after partitioning and enumeration under SOLC constraints. Figure 4 DAG and Connected to the same pseudo-entry node Table 1 shows the different maximum number of splits for in-vehicle augmented reality-dependent tasks. s The relationship with the decision space, among which .

[0027] Table 1 Comparison of decision space size for example dependency tasks under different maximum split numbers.

[0028] 3) System Model and Problem Formalization a. Communication model This invention employs a frequency division multiple access (FDMA) mechanism, where the system uplink bandwidth is evenly distributed according to the number of vehicles connected to the same RSU. Since different vehicles occupy orthogonal frequency bands for data transmission, interference between vehicles within the same RSU coverage area is effectively avoided. The uplink data transfer rate to the edge server is: (1) In the formula For the total uplink bandwidth, ( x+k () represents the total number of vehicles within the RSU coverage area. For the vehicle's transmission power, For vehicles Channel gain of edge servers Noise power; The transmission power of the edge server is denoted as Similarly, the connection between the edge server and the vehicle can be derived. downlink data transmission rate ; The The data volume of each subtask is denoted as . The vehicle was obtained subtasks Transmission latency to the edge server: (2) Similarly, it can be concluded that the edge server will handle subtasks. Assisted unloading to idle vehicles The delay is denoted as ; The energy consumption of uploading subtasks to the edge server depends on the vehicle's transmission power and the data transmission latency. The transmission energy consumption is expressed as: (3) Similarly, the edge server can be directed to idle vehicles. Transmission subtask Energy consumption: (4) Subtask The amount of data resulting from the calculation is denoted as . Therefore, we can conclude that Energy consumption for transmitting calculation results from idle vehicles to the edge server: (5) In the formula For idle vehicles Similarly, the uplink data transfer rate to the edge server can be derived. The calculation results are transmitted from the edge server to the energy consumption of the task vehicle and the idle vehicle, respectively denoted as... and ; Export task result feedback specifically refers to the process by which the edge server feeds back the export task processing result to the corresponding task vehicle; the amount of subtask result data is much smaller than the amount of subtask data, so the latency and energy consumption of result feedback are negligible. b. Computational Model Vehicle calculation frequency is denoted as f c The computation frequency of a single processing unit on an edge server is denoted as... f mec Then subtask The computational latency at the vehicle end is: (6) Therefore, the subtask is derived. Energy consumption calculation at the vehicle end: (7) In the formula For vehicles at a calculated frequency of f c Calculate the power corresponding to the task in real time; Subtask In the processing unit The computational latency and energy consumption are shown below: (8) (9) In the formula For a single processing unit of an edge server at a computing frequency of f mec Calculate the power corresponding to the task in real time; c. Task latency and energy consumption model Subtasks of a dependency-based task have strict dependencies on each other. When subtasks are offloaded to different edge servers for execution, this can affect non-entry point tasks. Its execution requires the following prerequisite: only when all first-level precursor subtasks are executed. The calculation is completed, and the corresponding result data is transmitted to... The subtask can only be started and executed after it is located in the processing unit. In the processing unit The start time of execution can be defined as: (10) In the formula This indicates that, without considering dependency constraints, the processing unit Able to provide The earliest moment when computing services were provided, express The completion time of the neutron mission express The computation results of the neutron task are transmitted to The transmission latency at the current location is affected by the consistency constraint at the subtask unloading location. It exists only in one case, namely and All subtasks on the given path are processed on the vehicle side, while the remaining subtasks are processed on the edge server. or ,in and They represent The latency of transmitting the calculation results from the edge server to the task vehicle and the idle vehicle; For subtasks In the processing unit The calculation completion time is represented as follows: (11) For a dependent task V If both its entry and exit tasks are in the processing unit Execution can be performed to determine when it begins execution. Thus, its completion time is obtained. For the first-level successor subtask of the entry task The completion time can be obtained from formulas (10) and (11), and so on until the exit task. , for The completion time is also the completion time of this dependent task; Will V The time of its generation is recorded as ,but V Waiting delay and completion delay As shown in equations (12) and (13) respectively: (12) (13) For a dependent task V If its If the idle vehicle completes the task, then V The total latency should be On top of that, data is transmitted to the edge server. Transmission delay of calculation results If its If completed locally on the vehicle or on an edge server, then V The total delay is ,use express V The total delay is then: (14) V Total energy consumption includes: the computational energy consumption of subtasks locally. Energy consumption of subtasks offloading to edge servers The computational energy consumption of subtasks on edge servers Energy consumption of idle vehicles assisting in unloading The subtask calculates the energy consumption of idle vehicles. Energy consumption for transmitting subtask calculation results between vehicles and edge servers ,use express V The total energy consumption is then: (15) in, i This refers to a subtask computed locally. j This refers to a subtask computed on an edge server. k This indicates a subtask computed on an idle vehicle. d. Problem formalization Different unloading methods and processing orders for subtasks will affect the overall completion latency of dependent tasks. For mission vehicles The set of subtask unloading decisions, Indicates the mission vehicle subtasks Process locally. express In the processing unit deal with, express idle vehicles Processing, defining For mission vehicles The set of subtask priority weights, for ,express subtasks and Executed in the same place, and Prior to implement; Will handle dependency tasks V Expenses Defined as the weighted sum of latency and energy consumption, then: (16) in As a weighting factor; System overhead is defined as the average of the total overhead of all task vehicles in the system for completing all dependent tasks they generate; if the system k A total of [number] vehicles generated R A dependent task, using V r To differentiate between different dependency tasks, the optimization problem can be formalized as: (17) This is a logic constraint for the execution of subtasks of a dependent task, indicating that the start time of any subtask cannot be earlier than the completion time of its first-level predecessor subtask. As constrained by time delay and energy consumption weighting factors, As a constraint on the total task delay, and Consistency constraints for the unloading location of subtasks. Indicates when subtask When processing locally, They should be processed locally together. Indicates when subtask When handling idle vehicles Should be with Processed in the same idle vehicle.

[0029] 4) LD-BGMH Algorithm To solve the optimization problem described by equation (17), this invention proposes the LD-BGMH algorithm, which includes three core mechanisms: resource allocation constraints, dynamic subtask sorting, and dependent task unloading matching. First, it formulates an allocation strategy for processing units to ensure the fairness of resource allocation in multi-user scenarios. Second, it constructs a dynamic subtask sorting strategy based on critical paths and dependency strength to clarify the execution priority of subtasks within the same processing unit and effectively reduce the total task latency. Finally, under the consistency constraint of subtask unloading positions, it deeply integrates the traditional bipartite graph matching-Hungarian algorithm with the layer-by-layer greedy partitioning algorithm based on DAG hierarchy to form a task unloading solution suitable for dependent constraints. a. Resource allocation strategy Edge servers consist of multiple processing units, but for the same dependent task, only one processing unit is allocated to it, and this resource is continuously occupied until the outgoing task is completed and released. Subtasks requiring auxiliary unloading are also required to be allocated to the same processing unit on an idle vehicle. This approach not only avoids a single task consuming excessive resources and ensures fairness for multiple users in resource-constrained scenarios, but also simplifies the resource allocation process, reduces resource contention between multiple tasks, and ensures that idle vehicles still have available computing resources to process their own tasks.

[0030] b. Subtask dynamic sorting algorithm by Figure 4 Partial subtask sequence For example, subtasks v 2 and v 3. Since they are independent of each other, if their execution order is not clearly defined when they are scheduled to be executed in the same processing unit, they will be assigned the same start time. This contradicts the actual mechanism of serial task processing in the processing unit, leading to deviations in the calculation of performance indicators such as latency and energy consumption, and affecting the decision-making accuracy of the optimization algorithm. Furthermore, the difference in the execution order of subtasks affects the total latency of the task. To solve the above problems and further reduce the total latency of the task, this invention establishes the execution order of subtasks based on their average computation latency and average communication latency.

[0031] Subtask v j The average computation delay is shown in the following formula: (18) Subtasks v j In the processing unit q w computational latency, m This refers to the number of edge server processing units. x This represents the number of available vehicles.

[0032] Subtask and v j The average communication delay is expressed as: (19) To reduce the computational complexity of average communication latency, the default value is used here. v j Computation is performed on the edge server, and the data is retrieved. v i Transmitted in different idle vehicles v j Average communication latency of the required result data.

[0033] In a DAG of a dependency task, this invention defines the critical path as: from arrive Among all paths, the path with the largest weighted sum of average computation latency and average communication latency is selected. Similar to how the capacity of a barrel is determined by its shortest stave, the shortest completion time of the entire dependent task is constrained by the longest path, and the critical path typically corresponds to this longest path. Therefore, the scheduling priority of subtasks on the critical path within the DAG has a decisive impact on the total task latency.

[0034] Define subtasks v j Downward Dependency Strength , indicating from v j arrive The weights and the weights of the longest path are used for quantization. v j The degree of impact on the execution of subsequent subtasks. For subtasks with the same start time, the larger the downward dependency strength value, the closer it is to the critical path, and the more significant its execution delay is on the overall task completion time. Therefore, it should be scheduled for execution first. The expression is as follows: (20) in ; Define subtasks v j Upward dependence strength , indicating from arrive v j The weights of the largest and largest paths are used for quantization. v j The degree of dependence on predecessor subtasks. The higher the upward dependency strength value, the greater the dependence on predecessor subtasks, and the later the execution conditions are met, making it easy to become a bottleneck in dependent tasks. For such subtasks, once the execution conditions are met, they should be executed as soon as possible to avoid being squeezed out by other subtasks with low upward dependency strength. The expression is as follows: (twenty one) Taking into account both the critical path affecting task completion time and the predecessor dependency strength of subtasks, a dynamic subtask ranking algorithm based on critical path-dependency strength is proposed. v i priority Defined as and The weighted sum is as follows: (twenty two) in This is the weighting factor.

[0035] After a subtask is unloaded, it first enters a waiting queue (or an MEC buffer for edge servers). Subtasks that meet the execution conditions are then moved into the executable subtask pool and processed according to their... The values ​​are sorted from high to low to achieve priority scheduling. For example... Figure 5 As shown, in the waiting queue, the DAG representing dependent tasks is split into multiple sub-task nodes, whose dependencies remain unchanged. When the system starts, the sub-tasks... v 1. If the execution conditions are met, it is sent to the executable subtask pool. Since the subtask pool currently only contains... v 1, therefore v 1. Prioritizes execution. During execution, upon completion of each subtask, immediately check all its first-level successor subtasks. If all first-level predecessors of a successor subtask have been completed, thus meeting the execution conditions, it is moved to the executable subtask pool and further processed according to their... The subtasks are sorted by value, and the above process continues iteratively until the exit task is completed. Algorithm 6.1 describes the specific process of dynamic sorting of subtasks.

[0036] c. Dependency-based task unloading algorithm Existing research based on the Hungarian algorithm typically models task unloading as a bipartite graph matching problem to find the optimal mapping between tasks and available computing nodes, but this is difficult to directly apply to dependent task unloading scenarios. To address the unloading requirements of dependent tasks under the VEC architecture, this invention introduces a consistency constraint on subtask unloading positions, ensuring that dependent tasks... V It can be divided into at most two parts for unloading execution. At the same time, based on the Hungarian algorithm, a layer-by-layer greedy partitioning algorithm based on DAG hierarchy is introduced. The optimal unloading decision that satisfies the constraints is solved by a two-layer matching strategy that combines overall matching and partition matching.

[0037] In this invention, the unloading decision problem is abstracted as a directed bipartite graph matching problem, where the directed bipartite graph contains two disjoint sets of vertices: Task set: consisting of dependent tasks V It consists of all the sub-tasks.

[0038] Resource set: consisting of the vehicle that generated the task and the edge server. m Each processing unit, and x It consists of several idle vehicles.

[0039] In a bipartite graph, directed edges point only from the task set to the resource set, representing the potential allocation relationship between subtasks and available processing units. Since different processing units have different computing capabilities and task queue states, the weights of directed edges from the task set to the resource set are not completely consistent. The optimization objective is to find the matching scheme with the minimum weight sum. Figure 6 One possible resource matching scenario is listed below: V -1 was assigned to an idle vehicle. deal with, V -2 was assigned to the edge server. m One processing unit, and V = V -1 V -2.

[0040] The matching mechanism includes dependent tasks. V Overall matching and segmentation matching. First, execute... V The overall match will V All subtasks are treated as an indivisible whole, and the same processing unit is allocated to all subtasks to calculate the minimum cost of overall matching. The specific process is as follows: (1) Define the elements and edge weights in the directed bipartite graph, where the left vertex set is the task set, represented as: The right-hand vertex set is a resource set, containing all available processing units, i.e. These correspond to local task vehicles, idle vehicles, and edge servers, respectively. m Each processing unit has an edge weight determined by... Representation. Construction. weight matrix As shown below: (twenty three) In the formula express V The weight values ​​corresponding to different vehicle processing units, i.e., when i=j= 1 hour indicates V With mission vehicle processing unit The weight, express V The weight values ​​correspond to different edge server processing units. The task set contains only one element, therefore when... When the value is set to 0, other values ​​are initialized to 0, indicating that any match is allowed without affecting the minimum matching result.

[0041] (2) Call the Hungarian algorithm to adjust the weight matrix H Solve for the result that makes V The resource matching scheme with the lowest cost and its cost value Algorithm 6.2 describes in detail the process of the Hungarian algorithm under global matching.

[0042] After the overall matching is complete, execute V Segmentation matching. V It can be divided into at most two parts, each containing an entry task and an exit task. Resource matching is performed on each of the found valid partitioning schemes to determine the minimum cost of partition matching. The specific process is as follows: (1) To V The DAG is used for segmentation, employing a layer-by-layer greedy segmentation algorithm based on the DAG hierarchy. Starting from the layer containing the entry task, an initial segmentation scheme is first constructed. Then, all legal combinations of the subtask and the already segmented parts are traversed layer by layer, retaining only the first two locally optimal segmentation strategies in each layer. This design retains the advantages of low complexity and high solution efficiency of traditional greedy algorithms while mitigating their short-sightedness, making it suitable for resource-constrained scenarios that require rapid output of high-quality solutions.

[0043] (2) The result of the segmentation is denoted as V -1 and V -2, the task set is represented as The resource set remains unchanged, but the edge weights are adjusted. and Representation. Construction. weight matrix And call the Hungarian algorithm to solve for the weight matrix. N As shown below: (twenty four) (3) When dividing the subtasks of different layers, each layer except the layer where the entry task is located will produce two matching results, which are denoted as the optimal solutions. and suboptimal solutions Based on this, when moving to the next level of partitioning, the two candidate solutions from the previous level are expanded, resulting in a maximum of four candidate solutions. Then, the two solutions with the lowest cost are selected, and the solution is updated accordingly. and The value of is determined after the final partitioning. The minimum cost among all candidate solution costs is selected and denoted as . Algorithm 6.3 describes in detail the process of segmentation and matching for dependency tasks.

[0044] Due to the consistency constraint of the subtask unloading location, in the case of segmentation matching, the sub-DAG with the entry task cannot be unloaded to the vehicle end. Therefore, after the algorithm is executed, if the output decision does not meet the above constraints, all the local optimal decisions generated during the algorithm's execution are backtracked, and the unloading decision with relatively small overhead that meets the requirements is selected from these decisions.

[0045] After the two sub-algorithms have finished executing, and Choose the smaller value as V Expenses Simultaneously, it outputs the subtask unloading scheme corresponding to the cost value. After task unloading, the subtasks are executed according to the sorting algorithm. If the processed dependent task... V The number of nodes in the DAG is n The level is l The number of elements in the resource set is r The time complexity of the unloading algorithm is then O(n). .

[0046] 5) Simulation results To verify the effectiveness of the LD-BGMH algorithm, performance simulation analysis will be performed on the proposed scheme using Python 3.6. Furthermore, a horizontal comparison with the following five algorithms will be conducted to demonstrate the effectiveness of the proposed algorithm. The comparison algorithms are as follows: (a) Local processing: All dependent tasks are processed locally by the task vehicle.

[0047] (b) Edge Server Offloading (Mec): All dependent tasks are offloaded to the edge server. This algorithm allows the edge server to provide multiple processing units for a set of dependent tasks for the same vehicle.

[0048] (c) Random offloading: Randomly decides the execution location of tasks that depend on other tasks, which can be processed locally or offloaded to edge servers and idle vehicles.

[0049] (d) Greedy Algorithm: When unloading dependent tasks, a greedy strategy is used to match resources. It traverses all available computing resources and allocates the resources that minimize the current overhead to each subtask, only pursuing the local immediate optimal unloading decision.

[0050] (e) Traditional bipartite graph matching-Hungarian algorithm (BGMH): The DAG of dependent tasks is randomly and legally divided into two sub-task sets (not fragmented node splitting), thereby constructing a bipartite graph task set and performing matching solution. Compared with the proposed algorithm, it removes the overall matching and layer-by-layer greedy partitioning.

[0051] Simulation parameters Table 2 Simulation Parameters

[0052] The simulation scenario of this invention is set in an urban traffic section with a coverage radius of 500 meters. Within the coverage area, there are 5 task vehicles and 6 idle vehicles. Task vehicles randomly generate dependent tasks at the start of the simulation. To simulate the dependencies between vehicle tasks in a real-world scenario, a Directed Acyclic Graph (DAG) generator is constructed to describe subtasks and their dependencies, and the generated DAG is randomly assigned to each task vehicle. Table 2 details the parameter settings in the system.

[0053] Results Analysis This invention will analyze the performance of the dependency-based task scheduling and offloading scheme proposed in this invention from four perspectives: system overhead, resource utilization, and task completion rate under different task numbers, and response latency under different task dependency structures, in resource-constrained application scenarios.

[0054] resource utilization rate Defined as: the actual processing time of each resource in the system for subtasks. Total time from system startup until all resources are idle The average of the ratios. Therefore: (25) In the formula , and These represent the actual processing time of subtasks by the processing units of different task vehicles, idle vehicles, and edge servers.

[0055] Experiment 1: The impact of subtask sorting algorithms on the LD-BGMH algorithm Figure 7 The system overhead and resource utilization of two algorithms under different numbers of dependent tasks are illustrated. L-BGMH is a comparison algorithm of the LD-BGMH algorithm of this invention after removing the dynamic subtask sorting algorithm based on critical path-dependency strength. To avoid execution logic contradictions caused by the lack of explicit sorting rules, L-BGMH introduces a basic sorting rule: for subtasks that simultaneously meet the execution conditions, they are executed serially in ascending order of DAG node numbers. The horizontal axis in the figure represents the number of dependent tasks. Unless otherwise specified, each task represents a randomly generated dependent task consisting of 3-10 subtasks.

[0056] like Figure 7As shown in (a), when the number of tasks is less than 15, the system overhead of the two algorithms is similar. This is because the system is under low load, and the benefits of the sorting algorithm are limited. As the number of tasks increases, the difference in system overhead between the two algorithms gradually widens, indicating that the sorting algorithm effectively reduces the overhead incurred by subtasks waiting for predecessor results by prioritizing critical path subtasks. Figure 7 In (b), when the number of tasks is less than 15, the resource utilization difference between the two algorithms is small. When the number of tasks reaches 50, the resource utilization of LD-BGMH is 9.3% higher than that of L-BGMH. This is due to the timely processing of critical path subtasks by the sorting algorithm, which significantly shortens the time for subtasks to wait for predecessor results, thereby improving resource utilization. In summary, the subtask dynamic sorting algorithm based on critical path-dependency strength has a significant impact on the performance of LD-BGMH.

[0057] Experiment 2: System overhead of different algorithms under different numbers of tasks Figure 8 The system overhead of different algorithms under varying numbers of tasks is shown. When the number of tasks is less than 15, the system overhead differences between LD-BGMH, BGMH, and Greedy algorithms are not significant. This is because, under low load, the disadvantage of random partitioning in BGMH and the local greedy characteristic in Greedy are masked by sufficient resources. As the number of tasks increases, the system overhead of LD-BGMH is significantly lower than other algorithms, demonstrating a stable advantage in both low and high load scenarios. The Mec algorithm enters a high-load state prematurely, and its performance is second only to the top three. The Local algorithm, due to its ability to execute only locally and extremely limited resources, exhibits high overhead from the early stages of the experiment. The Random algorithm, due to random partitioning and offloading, suffers from a dramatic increase in subtask communication overhead and waiting for predecessor computation results, and the system resource load is severely unbalanced, resulting in the worst performance.

[0058] Experiment 3: Resource utilization of different algorithms under different numbers of tasks Figure 9The resource utilization of different algorithms under different task numbers is shown. Since the Local algorithm executes tasks only locally, it has high resource utilization but limited performance and is therefore not included in the comparison. When the number of tasks is 5-15, the resource utilization of LD-BGMH, BGMH, and Greedy algorithms increases rapidly because idle resources are gradually occupied. When the number of tasks exceeds 15, the growth rate of resource utilization for the three algorithms slows down and tends to stabilize, eventually settling at 95%, 89.7%, and 90.3%, respectively. Due to relatively limited resources, the growth rate of the Mec algorithm slows down after the number of tasks reaches 10. When the number of tasks is 10-30, Mec's resource utilization is higher than LD-BGMH, but the gap narrows as the number of tasks increases. The former phenomenon is mainly because the resources in Mec are equivalent to the 8 processing units of the edge server, and there is no waiting latency in transmitting result data between subtasks. The latter is because, under the same conditions, the resource load in Mec is higher than that in LD-BGMH. The Random algorithm has the worst resource utilization, especially when the number of tasks exceeds 30, which is due to the chaotic resource load caused by its random allocation strategy.

[0059] Experiment 4: Task completion rate of different algorithms under different numbers of tasks Figure 10 This section demonstrates the task completion rates of different algorithms under varying numbers of tasks. The task completion rate is defined as the percentage of dependent tasks that did not time out. (If dependent tasks...) V r Total latency Exceeding its maximum completion delay ,but V r Timeouts occurred. When the number of tasks was less than 20, the LD-BGMH, BGMH, and Greedy algorithms could all complete all tasks. When the number of tasks increased to 30-50, the task completion rates of all three algorithms decreased. This was due to the excessively long task queues, causing some subtasks to be processed untimely, leading to timeouts. At 50 tasks, the task completion rates of the three algorithms were 96%, 80%, and 82%, respectively, with LD-BGMH performing best. The Mec algorithm could complete all tasks with 10 tasks, but this dropped to 44% with 50 tasks. The Local and Random algorithms failed to complete all tasks initially; the former due to insufficient resources, and the latter due to unreasonable resource allocation.

[0060] Experiment 5: Comparison of response latency for different task-dependent structures Figure 11This study demonstrates the response latency of different algorithms under various task dependency structures. Algorithm response latency is defined as the time interval from the input of a single dependent task to the output of the algorithm's unloading decision. For multi-task scenarios, this metric is the sum of the response latencies of all tasks. The task dependency structures involved in this experiment are defined as follows: For serial tasks, all subtasks except the entry and exit tasks have unique predecessor and successor subtasks; for parallel tasks, all subtasks except the entry and exit tasks have the entry task as the predecessor and the exit task as the successor; simple DAG tasks may contain multiple serial-parallel relationships with a relatively small number of subtasks; the first three types of tasks are randomly composed of 3-10 subtasks; complex DAG tasks are randomly composed of 10-20 subtasks, and due to the relatively large number of subtasks, the internal dependencies are more complex. Since the Local algorithm lacks a task unloading operation and the Random algorithm lacks targeted optimization, they are not included in the comparison.

[0061] Figure 11 In the analysis, the BGMH algorithm maintains the minimum response latency under all four task dependency structures, and the latency is independent of the task dependency structure. This is because BGMH omits overall matching and layer-by-layer greedy partitioning, solving only through random valid partitioning and bipartite graph matching. Its response latency is determined solely by the matching process and is unaffected by the task structure. The Mec algorithm has a slightly lower response latency than the LD-BGMH algorithm under parallel tasks and simple DAG tasks, but the latency difference is further widened under serial tasks and complex DAG tasks. This is because Mec reduces the number of resources compared to LD-BGMH. The time complexity of both algorithms is affected by the number of subtasks, the number of subtask layers, and the number of resources. In scenarios with few subtasks and few layers, Mec has a slightly better response latency, but the difference is amplified in serial (many subtask layers) and complex DAG (many subtasks and many layers) scenarios. Taking 50 tasks as an example, the response latency of LD-BGMH under different task dependency structures is: 17.4ms for serial tasks, 15.1ms for parallel tasks, 15.7ms for simple tasks, and 30.3ms for complex tasks. This further verifies the impact of the number of subtasks, the number of subtask layers, and the number of resources on the algorithm's response latency. Although the response latency of LD-BGMH is slightly higher than that of Mec and BGMH, it is still in the millisecond range and can be ignored compared to the task processing latency. Therefore, LD-BGMH achieves a significant improvement in system performance at the cost of millisecond-level latency, and its trade-off strategy is reasonable. The Greedy algorithm has significantly higher response latency than other algorithms under all task dependency structures, and its performance is the worst.

[0062] in conclusion This invention studies the scheduling and offloading problem of dependent tasks under the VEC architecture. Unlike existing work, this invention, targeting application scenarios with limited edge resources, designs a centralized two-layer scheduling and offloading architecture with edge server decision-making and idle vehicle assistance. It constructs a system overhead optimization model with subtask dependency constraints and offloading position consistency constraints, and proposes a dependent task scheduling and offloading algorithm called LD-BGMH. To verify the effectiveness of the proposed algorithm, a series of simulation experiments were conducted. Experimental results show that the subtask dynamic sorting sub-algorithm in the LD-BGMH algorithm can dynamically plan the execution order of subtasks according to the task dependency structure and resource load status, effectively reducing the idle blocking time of subtasks waiting for predecessor calculation results, reducing the total system overhead from the execution scheduling level, and improving resource utilization. Comparison with five baseline algorithms further shows that regardless of whether the system is running smoothly under low load or under high load and resource constraints, the proposed LD-BGMH algorithm can efficiently utilize the collaborative resources of idle vehicles and edge nodes, effectively reducing system overhead while ensuring a high task completion rate.

[0063] It should be noted that in this invention, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising a reference structure" does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0064] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A centralized dependency task scheduling offloading optimization algorithm for a vehicle-to-edge network, characterized in that: Includes the following: 1) VEC-based Dependency Offloading Architecture for Vehicle Assistance a. VEC architecture; 2) Consistency constraint between task model and subtask unloading location a. DAG model; b. Consistency constraints on subtask unloading location; 3) System Model and Problem Formalization a. Communication model; b. Computational model; c. Task latency and energy consumption model; d. Formalize the problem; 4) LD-BGMH Algorithm a. Resource allocation strategy; b. Subtask dynamic sorting algorithm; c. Dependency-based task unloading algorithm; 5) Simulation results.

2. The centralized dependency task scheduling offloading optimization algorithm for a vehicle edge network according to claim 1, characterized in that: The VEC architecture includes an edge computing service unit within the RSU coverage area, and the mission vehicle is... express, Indicates the first task generated One vehicle, the available vehicle is... This indicates that the number of vehicles on the mission is... k The number of available vehicles is x The processing units in the edge server consist of a set express, For the first in the edge server Each processing unit generates scalable, dependent tasks from task vehicles. Under resource constraints, the resulting subtasks can be offloaded to edge servers and idle vehicles. V Part of the subtasks in 2 are processed at the edge, while another part is assisted in being unloaded to idle vehicles.

3. The centralized dependency task scheduling offloading optimization algorithm for a vehicle-to-everything edge network according to claim 1, wherein: The consistency constraints between the task model and the subtask unloading location are as follows: a. DAG model; To accurately describe the dependency relationship between sub-tasks in dependent tasks, a directed acyclic graph is used to model the tasks, and the DAG is usually represented by a binary tuple for a single dependent task V , and its corresponding DAG model is given by definition; b. Consistency constraints on subtask unloading location; For a maximum of being divisible into Dependent tasks V Its uninstallation strategy needs to be implemented on the vehicle's local machine and on the edge server. m Each processing unit and x When choosing a combination of execution locations from three types of idle vehicles, without considering the partitioning and enumeration of dependent tasks, the size of its decision space is... for , s It grows exponentially, making optimization extremely complex; Under the Subtask Offload Location Consistency (SOLC) constraint, regardless of s What value should be taken? V It can be divided into two parts for execution at most. These two parts can be either unloaded to the same location, in which case the entire task is equivalent to not being split and executed, or one part can be processed on the edge server and the other part can be processed on the vehicle.

4. The centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks according to claim 1, characterized in that: The system model and problem are formalized as follows: a. Communication model The system employs a frequency division multiple access (FDMA) mechanism, where uplink bandwidth is evenly distributed based on the number of vehicles connected to the same RSU. Because different vehicles occupy orthogonal frequency bands for data transmission, interference between vehicles within the same RSU coverage area is effectively avoided. The uplink data transfer rate to the edge server is: (1) In the formula For the total uplink bandwidth, ( x+k () represents the total number of vehicles within the RSU coverage area. For the vehicle's transmission power, For vehicles Channel gain of edge servers Noise power; The transmission power of the edge server is denoted as , and the downlink data transmission rate of the edge server to the vehicle is derived as ; The The data volume of each subtask is denoted as . The vehicle was obtained subtasks Transmission latency to the edge server: (2) By analogy, it is concluded that the edge server will offload the subtask to the idle vehicle with a latency, denoted as ; and ; The energy consumption of uploading subtasks to the edge server depends on the vehicle's transmission power and the data transmission latency. The transmission energy consumption is expressed as: (3) By analogy, it is derived that the edge server transmits to the idle vehicle subtasks of energy consumption: (4) Subtask The amount of data resulting from the calculation is denoted as . Therefore, we can conclude that Energy consumption for transmitting calculation results from idle vehicles to the edge server: (5) In the formula For idle vehicles Similarly, the uplink data transfer rate to the edge server can be derived. The calculation results are transmitted from the edge server to the energy consumption of the task vehicle and the idle vehicle, respectively denoted as... and ; Export task result feedback specifically refers to the process by which the edge server feeds back the export task processing result to the corresponding task vehicle; the amount of subtask result data is much smaller than the amount of subtask data, so the latency and energy consumption of result feedback are negligible. b. Computational Model The computing frequency of the vehicle is denoted as f c The computing frequency of the edge server single processing unit is denoted as f mec The subtask The computing latency at the vehicle end is (6) Thus, the subtask Computational energy consumption at the vehicle end: (7) In the formula is the power corresponding to the calculation frequency f c of the calculation task; Subtasks The computation latency and energy consumption on the processing unit are shown as follows, respectively: (8) (9) In the formula For a single processing unit of an edge server at a computing frequency of f mec Calculate the power corresponding to the task in real time; c. Task latency and energy consumption model Subtasks of a dependency-based task have strict dependencies on each other. When subtasks are offloaded to different edge servers for execution, this can affect non-entry point tasks. Its execution requires the following prerequisite: only when all first-level precursor subtasks are executed. The calculation is completed, and the corresponding result data is transmitted to... The subtask can only be started and executed after it is located in the processing unit. In the processing unit The start time of execution can be defined as: (10) In the formula This indicates that, without considering dependency constraints, the processing unit Able to provide The earliest moment when computing services were provided, express The completion time of the neutron mission, express The computation results of the neutron task are transmitted to The transmission latency at the current location is affected by the consistency constraint at the subtask unloading location. It exists only in one case, namely and All subtasks on the given path are processed on the vehicle side, while the remaining subtasks are processed on the edge server. or ,in and They represent The latency of transmitting the calculation results from the edge server to the task vehicle and the idle vehicle; For subtasks In the processing unit The calculation completion time is represented as follows: (11) For a dependent task V If both its entry and exit tasks are in the processing unit Execution can be performed to determine when it begins execution. Thus, its completion time is obtained. For the first-level successor subtask of the entry task The completion time can be obtained from formulas (10) and (11), and so on until the exit task. , for The completion time is also the completion time of this dependent task; Will V The time of its generation is recorded as ,but V Waiting delay and completion delay As shown in equations (12) and (13) respectively: (12) (13) For a dependent task V If its If the idle vehicle completes the task, then V The total latency should be On top of that, data is transmitted to the edge server. Transmission delay of calculation results If its If completed locally on the vehicle or on an edge server, then V The total delay is ,use express V The total delay is then: (14) V Total energy consumption includes: the computational energy consumption of subtasks locally. Energy consumption of subtasks offloading to edge servers The computational energy consumption of subtasks on edge servers Energy consumption of idle vehicles assisting in unloading The subtask calculates the energy consumption of idle vehicles. Energy consumption for transmitting subtask calculation results between vehicles and edge servers ,use express V The total energy consumption is then: (15) in, i This refers to a subtask computed locally. j This refers to a subtask computed on an edge server. k This indicates a subtask computed on an idle vehicle. d. Problem formalization Different unloading methods and processing orders for subtasks will affect the overall completion latency of dependent tasks. For mission vehicles The set of subtask unloading decisions, Indicates the mission vehicle subtasks Process locally. express In the processing unit deal with, express idle vehicles Processing, defining For mission vehicles The set of subtask priority weights, for ,express subtasks and Executed in the same place, and Prior to implement; Defining the overhead of processing dependent tasks V as a weighted sum of latency and energy consumption, we have: ​ (16) wherein is a weighting factor; System overhead is defined as the average of the total overhead of all task vehicles in the system for completing all dependent tasks they generate; if the system k A total of [number] vehicles generated R A dependent task, using V r To differentiate between different dependency tasks, the optimization problem can be formalized as: (17) This is a logic constraint for the execution of subtasks of a dependent task, indicating that the start time of any subtask cannot be earlier than the completion time of its first-level predecessor subtask. As constrained by time delay and energy consumption weighting factors, For the total task delay constraint, and Consistency constraints for the unloading location of subtasks. Indicates when subtask When processing locally, They should be processed locally together. Indicates when subtask When handling idle vehicles Should be with Processed in the same idle vehicle.

5. The centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks according to claim 1, characterized in that: The LD-BGMH algorithm comprises three core mechanisms: resource allocation constraints, dynamic subtask sorting, and dependent task unloading matching. First, it establishes an allocation strategy for processing units to ensure fairness in resource allocation within multi-user scenarios. Second, it constructs a dynamic subtask sorting strategy based on critical paths and dependency strength, clarifying the execution priority of subtasks within the same processing unit and effectively reducing total task latency. Finally, under the constraint of consistent subtask unloading locations, it deeply integrates the traditional bipartite graph matching-Hungarian algorithm with a layer-by-layer greedy partitioning algorithm based on DAG hierarchy, forming a solution suitable for task unloading with dependency constraints.

6. The centralized dependency-based task scheduling and offloading optimization algorithm for vehicle-to-everything (V2X) edge networks according to claim 1, characterized in that: The simulation results are compared horizontally with the following five algorithms to demonstrate the effectiveness of the proposed algorithm. The comparison algorithms are as follows: (a) Local processing: All dependent tasks are processed locally by the task vehicle; (b) Edge server offloading: All dependent tasks are offloaded to the edge server. This algorithm allows the edge server to provide multiple processing units for a group of dependent tasks for the same vehicle. (c) Random offloading: Randomly decides the execution location of tasks that depend on other tasks, which can be processed locally or offloaded to edge servers and idle vehicles; (d) Greedy Algorithm: When unloading dependent tasks, a greedy strategy is used to match resources. It traverses all available computing resources and allocates the resources that minimize the current overhead to each subtask, only pursuing the local immediate optimal unloading decision. (e) Traditional bipartite graph matching-Hungarian algorithm: The DAG of the dependent task is randomly and legally divided into two sub-task sets to construct the bipartite graph task set and perform matching solution. Compared with the proposed algorithm, the overall matching and layer-by-layer greedy partitioning are removed.

Images