A method, apparatus, and vehicle for time compensation of long-link tasks across controllers.

Abstract

This application relates to a time compensation method, apparatus, and vehicle for long-link tasks across controllers. The method includes: obtaining the long-link task currently to be executed by the vehicle and the controller nodes required to complete the long-link task; determining the total data execution time of the long-link task based on the controller nodes; comparing the total data execution time with the target data execution time of the long-link task to obtain a comparison result, wherein the target data execution time is the highest time corresponding to the completion of the long-link task; if the comparison result shows that the total data execution time is greater than or equal to the target data execution time, adjusting the execution priority of the long-link task in each controller node, and reducing the execution time of the long-link task based on the adjusted execution priority. The execution priority adjustment in this application only applies to the currently pending long-link task, does not consume additional computing power, does not affect other tasks in the system, and achieves more efficient resource utilization.

Description

Technical Field

[0001] This application relates to the field of automotive intelligent technology, specifically to a time compensation method, device, and vehicle for long-link tasks across controllers. Background Technology

[0002] With the development of automotive intelligence, the electronic and electrical architecture is carrying more and more functions, generating larger and larger amounts of data, and demanding higher computing power. At the same time, due to the explosive growth of chip computing power, computing power and communication are gradually concentrating on a small number of chips and communication trunks. This inevitably leads to multi-task concurrency, causing tasks to compete for computing power and communication bandwidth, resulting in waiting delays for some tasks and a decline in the effectiveness of software implementation.

[0003] Traditional methods for solving software queuing involve designing local priorities to ensure fast execution times in specific areas. Each node has its own independent priority setting and operates independently. This is effective for tasks that are closed-loop within a single chip. However, for long-chain tasks that cross controllers, the priorities of the same long-chain task can be inconsistent across different controller nodes, leading to uncontrollable issues or significant timing jitter. In practical applications, this results in poor stability of long-chain control functions, causing functional delays such as slower braking or slower light flashing. Summary of the Invention

[0004] In view of this, this application provides a time compensation method, apparatus, and vehicle for long-link tasks across controllers to solve the problem of inconsistent priorities in the design of local priorities in related technologies, which leads to uncontrollable and large time jitter deviations in the same long-link task on different controller nodes.

[0005] In a first aspect, this application provides a time compensation method for long-link tasks across controllers, the method comprising: Obtain the long-link task currently pending execution for the vehicle, as well as the controller nodes that the vehicle depends on to complete the long-link task; Based on the current execution status of the controller node, determine the total data execution time of the long-link task; The total data execution time is compared with the target data execution time of the long-link task to obtain the comparison result. The target data execution time is the highest time corresponding to the completion of the long-link task. If the comparison result shows that the total data execution time is greater than the target data execution time, then the execution priority of the long-link task in each controller node that has not yet been executed is adjusted, and the execution time of the long-link task is reduced based on the adjusted execution priority.

[0006] Furthermore, based on the current execution state of the controller node, the total data execution time of the long-link task is determined, including: Determine the type of controller node based on business requirements; Based on the type, controller nodes with deterministic time and controller nodes with indeterminate time are obtained; Obtain the base runtime and waiting runtime of long-linked tasks in controller nodes with indeterminate time, where the waiting runtime is related to the running priority of long-linked tasks in controller nodes with indeterminate time; The total data processing time is obtained by considering the fixed time corresponding to the controller node with a defined time, the basic running time and waiting time of long-link tasks in the controller node with an indeterminate time.

[0007] Furthermore, based on the fixed time corresponding to the controller node with a defined time, and the basic runtime and waiting runtime of long-link tasks in the controller node with an indeterminate time, the total data processing time is obtained, including: The base runtime and waiting runtime are summed to obtain the runtime of the controller node with uncertain time. The total data execution time is obtained by adding the running times of controller nodes at fixed and indefinite times.

[0008] Furthermore, adjust the execution priority of long-chain tasks in subsequent controller nodes that have not yet been executed, including: The running priority of long-link tasks is gradually increased by a preset level value, and the running time of long-link tasks is reduced based on the latest running priority after the preset level value is increased a preset number of times, so as to obtain a new total data running time. Compare the new total data execution time with the target data execution time. If the new total data execution time is less than or equal to the target data execution time, obtain the execution order of the controller nodes when the long-link task is completed. Based on the execution order, the latest running priority of long-link tasks in the controller node is gradually reduced from back to front. Under the premise that the total running time of the new data is less than or equal to the target running time of the data, the global priority configuration of the long-link tasks is obtained.

[0009] Furthermore, the method also includes: After comparing the new total data execution time with the target data execution time, if the new total data execution time is greater than the target data execution time, and there is a reference controller node whose latest priority for long-link tasks is the highest level, then the execution priority of long-link tasks in the reference controller node will no longer participate in the adjustment of increasing the preset level value. Here, the reference controller node is any controller node.

[0010] Furthermore, after comparing the new total data processing time with the target data processing time, the method also includes: If the total duration of the new data execution exceeds the target duration of the data execution, and the latest priority of the long-link task among all subsequent unexecuted controller nodes is the highest level, then the latest priority will be used as the global priority configuration for the long-link task.

[0011] Furthermore, the method also includes: If the comparison result shows that the total data execution time is less than or equal to the target data execution time, then the execution priority of long-link tasks in each controller node is maintained.

[0012] Secondly, this application provides a time compensation device for long-link tasks across controllers, the device comprising: The acquisition module is used to acquire the long-link tasks that the vehicle is currently waiting to execute, as well as the controller nodes that it depends on to complete the long-link tasks. The determination module is used to determine the total data execution time of long-link tasks based on the current execution status of the controller node; The comparison module is used to compare the total data execution time with the data execution target time of the long-link task and obtain the comparison result. The data execution target time is the highest time corresponding to the completion of the long-link task. The adjustment module is used to adjust the running priority of long-link tasks in each controller node that has not yet been executed if the comparison result shows that the total data running time is greater than the target data running time, and to reduce the running time of long-link tasks based on the adjusted running priority.

[0013] Thirdly, this application discloses a computer device, including: a memory and a processor, which are communicatively connected to each other. The memory stores computer instructions, and the processor executes the computer instructions to perform the time compensation method for long-link tasks across controllers as described in the first aspect or any corresponding embodiment.

[0014] Fourthly, this application provides a vehicle, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement a time compensation method for performing a long-link task across controllers according to the first aspect or any corresponding embodiment thereof.

[0015] In this embodiment, the system obtains the long-link task currently to be executed by the vehicle and the controller nodes required to complete the long-link task. Then, based on the current execution status of the controller nodes, it determines the total data execution time of the long-link task. The system then compares the total data execution time with the target data execution time of the long-link task in a globally coordinated manner. Based on the comparison results, the system adjusts the execution priority of the long-link task in each controller node that has not yet been executed. Based on the adjusted execution priority, the system reduces the execution time of the long-link task. This adjustment of execution priority only applies to the long-link task currently to be executed, without consuming additional computing power or affecting other tasks in the system. This results in more efficient resource utilization, solves the problems of inconsistent priorities, uncontrollable time, and large jitter in long-link tasks across controllers, avoids functional failures such as slow braking and delayed headlight flashing, and achieves end-to-end time controllability. Attached Figure Description

[0016] To more clearly illustrate the technical solutions in the specific embodiments of this application or the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0017] Figure 1 This is a flowchart illustrating a time compensation method for long-link tasks across controllers according to an embodiment of this application. Figure 2 This is a flowchart illustrating a time compensation method for long-link tasks across controllers according to another embodiment of this application; Figure 3 This is a schematic diagram of a control network for a long-link task across controllers according to an embodiment of this application; Figure 4 This is a flowchart illustrating a time compensation method for long-link tasks across controllers according to another embodiment of this application. Figure 5 This is a structural block diagram of a time compensation device for long-link tasks across controllers according to an embodiment of this application; Figure 6 This is a schematic diagram of the hardware structure of a computer device according to an embodiment of this application; Figure 7 This is a schematic diagram of the structure of a vehicle according to an embodiment of this application. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0019] It is understood that before using the technical solutions disclosed in the various embodiments of this disclosure, users should be informed of the types, scope of use, and usage scenarios of the personal information involved in this disclosure in an appropriate manner in accordance with relevant laws and regulations, and user authorization should be obtained.

[0020] It should be noted that, in the description of this application, 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. The terms "first," "second," etc., in this application are used to distinguish similar objects and are not used to describe a specific order or sequence.

[0021] With the development of automotive intelligence, the electronic and electrical architecture is carrying more and more functions, generating larger and larger amounts of data, and demanding higher computing power. At the same time, due to the explosive growth of chip computing power, computing power and communication are gradually concentrating on a small number of chips and communication trunks. This inevitably leads to multi-task concurrency, causing tasks to compete for computing power and communication bandwidth, resulting in waiting delays for some tasks and a decline in the effectiveness of software implementation.

[0022] Traditional methods for solving software queuing involve designing local priorities to ensure fast execution times within a specific area. This is effective for tasks that are closed-loop within a single chip. However, for long-link tasks that cross controllers, inconsistent priorities across different controller nodes can lead to uncontrollable issues or significant timing jitter. In practical applications, this can result in poor stability of long-link control functions, causing functional delays such as slower braking or slower light flashing.

[0023] To address the aforementioned issues, according to embodiments of this application, a time compensation method for long-link tasks across controllers is provided. It should be noted that the steps shown in the flowcharts of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Furthermore, although a logical order is shown in the flowcharts, in some cases, the steps shown or described may be executed in a different order than that shown here.

[0024] This embodiment provides a time compensation method for long-link tasks across controllers. Figure 1 This is a flowchart illustrating a time compensation method for long-link tasks across controllers according to an embodiment of this application, as shown below. Figure 1 As shown, this method can be applied to the central control unit inside a vehicle, and the method process includes the following steps: Step S101: Obtain the long-link task currently to be executed by the vehicle and the controller nodes required to complete the long-link task.

[0025] Optionally, in this embodiment, a long-link task across controllers is a complete business task, but it is composed of subtasks or execution fragments on multiple controller nodes. For example, braking, light control, steering, etc. are a whole task. To complete this long-link task, it needs to pass through controller nodes t1, t2, t3, t4...t11. That is, the long-link task is a complete end-to-end task to achieve the same function. The task will be split into multiple execution fragments and run on different controller nodes.

[0026] Taking vehicle braking as an example of a long-chain task to be executed, after the vehicle receives the "braking" task, it will be divided into 5 segments, running on 5 different controller nodes until the long-chain task is completed: 1. Sensing controller node: First detects the "applying brake" action and calculates the braking force. 2. Central calculation controller node: Receives the signal, determines whether to brake suddenly or gently, and calculates the braking force and wheel distribution. 3. Switch controller node: Forwards the braking signal to the corresponding execution area. 4. Regional hub controller node: Receives the instruction and prepares to drive the brake actuator. 5. Execution controller node (brake motor / hydraulic pump): Actually clamps the brake pads, bringing the car to a stop.

[0027] Step S102: Determine the total data execution time of the long-link task based on the current execution status of the controller node.

[0028] Optionally, the total data execution time of a long-link task is equal to the sum of the execution times of all controller nodes in the entire link. If the execution of the "braking" long-link task requires passing through 11 controller nodes, then T(total) = t1 + t2 + t3 + ... + t11, where ti represents the execution time of the i-th controller node.

[0029] Currently, based on the current execution status of each controller node, when calculating the runtime of each controller node, timestamps can be added to the start and end times of the execution of that controller node, and the corresponding time t can be calculated using the difference between the corresponding timestamps.

[0030] Step S103: Compare the total data execution time with the target data execution time of the long-link task to obtain the comparison result, wherein the target data execution time is the highest time corresponding to the completion of the long-link task.

[0031] Optionally, based on the business requirements of the long-link task to be executed, the target execution time (T target) of the data operation corresponding to the long-link task is obtained. It is the longest execution time allowed when the long-link task is completed, and it must satisfy T(total) ≤ T(target).

[0032] At this point, obtain the total real-time data execution time T(total) that is currently statistically recorded, and then compare T(total) with T(target) to obtain the comparison result.

[0033] Step S104: If the comparison result shows that the total data running time is greater than the target data running time, then adjust the running priority of the long link task in each controller node that has not been executed subsequently, and reduce the running time of the long link task based on the adjusted running priority.

[0034] Optionally, if the comparison result is T(total) > T(target), the task's execution priority is increased individually on each controller node it passes through but has not yet been executed, only for this long-link task. This does not increase the overall priority of the node or affect other tasks on the node. By increasing the execution priority, task queuing time is reduced, compressing the total data runtime and bringing it back within the target data runtime range.

[0035] If the comparison result is T(total) ≤ T(target), then the running priority of the long-link task in each of the controller nodes is maintained. In this embodiment, by obtaining the long-link task currently to be executed by the vehicle and the controller nodes required to complete the long-link task, and then determining the total data running time of the long-link task based on the current execution status of the controller nodes, the comparison result of the total data running time and the data running target time of the long-link task is compared in a globally coordinated manner. Based on the comparison result, the running priority of the long-link task in each controller node that has not yet been executed is adjusted, and the running time of the long-link task is reduced based on the adjusted running priority. This adjustment of running priority only applies to the long-link task currently to be executed, does not occupy additional computing power, does not affect other tasks of the system, and makes resource utilization more efficient. It solves the problems of inconsistent priorities, uncontrollable time, and large jitter of long-link tasks across controllers, avoids functional failures such as slow braking and delayed light flashing, and achieves end-to-end time controllability.

[0036] As an alternative embodiment, such as Figure 2 As shown, step S102 includes: Step S1021: Determine the type of controller node based on business requirements; Step S1022: Based on the type, obtain the controller node with a fixed time and the controller node with an indefinite time; Step S1023: Obtain the base runtime and waiting runtime of the long-link task in the controller node with uncertain time, wherein the waiting runtime is related to the running priority of the long-link task in the controller node with uncertain time; Step S1024: Based on the fixed time corresponding to the controller node with a certain time, the basic running time and waiting running time of the long link task in the controller node with an uncertain time, the total data running time is obtained.

[0037] Optionally, such as Figure 3 As shown, based on the competition for operating resources and business needs, controller nodes are divided into: controller nodes with fixed time (exclusive links, no task contention, such as t1, t11) and controller nodes with indefinite time (multiple tasks concurrent, with preemption queuing, such as t2-t10).

[0038] Deterministic controller nodes: Dedicated to the operating environment, with no other tasks competing for time, and fixed time without deviation.

[0039] Controller nodes with uncertain time: multiple tasks run in parallel, with high-priority tasks jumping in the queue, and the running time = base running time + waiting running time.

[0040] The table below organizes and prioritizes all tasks of the t2 controller node. The table shows the running priority and waiting time Δt for each long-link task under the t2 controller node.

[0041]

[0042] Then, the time of the controller node with a fixed time and the time of the controller node with an uncertain time are added together to obtain the total data running time T(total): T(total) = fixed time of the controller node with a fixed time + (base running time of the controller node with an uncertain time + waiting running time).

[0043] In this embodiment, by accurately breaking down the entire time chain, the root cause of time delay (only controller nodes with uncertain times have time fluctuations) is located, thus avoiding blindly optimizing the running priority.

[0044] As an optional embodiment, step S1024 above includes: Step a1: Sum the base running time and the waiting running time to obtain the running time corresponding to the controller node with uncertain time. Step a2: Add the running times of the controller nodes at fixed and uncertain times together to obtain the total data running time.

[0045] Optionally, as described in the above embodiments, the total time T (total data processing time) of the entire link is determined by the base processing time and the waiting time corresponding to the processing priority of the long link task. The base processing time is fixed, while the waiting time corresponding to the processing priority will fluctuate depending on the selected processing priority. For example, for a long link task X, its corresponding T (total) = t(x)1 + t(x)2 + Δt(x.processing priority)2.... + t(x)11, where the processing times of t(x)1 and t(x)11 are fixed and do not require adjustment of the processing priority.

[0046] Calculation logic: The fixed times of all controller nodes with fixed times are directly summed, and then summed with the calculation and running times of all controller nodes with uncertain times to obtain the final total duration of the entire link.

[0047] Example: Total braking task duration = fixed time of sensing nodes + central SOC (basic running time + waiting running time) + switch (basic running time + waiting running time) + regional MCU (basic running time + waiting running time) + fixed time of execution nodes.

[0048] As an alternative embodiment, such as Figure 4 The above step S104 includes: Step S1041: Gradually increase the running priority of long-link tasks by a preset level value, and based on the latest running priority after increasing the preset level value by a preset number of times, reduce the running time of long-link tasks to obtain a new total data running time. Step S1042: Compare the new total data execution time with the target data execution time. If the new total data execution time is less than or equal to the target data execution time, obtain the execution order of the controller nodes when the long link task is completed. Step S1043: Based on the execution order, the latest running priority of long-link tasks in the controller node is gradually reduced from back to front. Under the premise of ensuring that the total running time of the new data is less than or equal to the target running time of the data, the global priority configuration of the long-link tasks is obtained.

[0049] Optionally, the total data processing time can be adjusted by adjusting the execution priority of long-chain tasks in subsequent controller nodes that have not yet been executed. The specific adjustment method is as follows.

[0050] Comparing T(total) with T(target), if T(total) ≤ T(target) during program execution, the running priority setting of long-link tasks in each controller node is maintained.

[0051] If the total (T) > T (target), in subsequent operation stages, the operation priority is first calculated according to the preset level value, such as level one. After the subsequent stages are upgraded by one level, if T (new total) ≤ T (target), then the execution order of the controller nodes that have not yet been executed when the long-link task is completed is obtained (e.g., perception controller node - central computing controller node - switch controller node - regional hub controller node - execution controller node). Starting from the last controller node, the previous operation priority is gradually restored (that is, the latest operation priority of the long-link task in the controller node is gradually reduced from the last to the first). Under the premise of ensuring that T (new total) ≤ T (target), until T (new total) > T (target), the priority of the corresponding step is maintained at one level, and the original priority design is maintained afterward.

[0052] If the overall priority is increased by one level and T(new total) > T(target), then subsequent steps will be considered to increase the priority by two levels. If, after increasing the priority by two levels, T(new total) ≤ T(target), the previous running priority will be gradually restored from the end to the beginning until T(total) > T(target). In this case, the running priority of the long-link task on the corresponding controller node will maintain the design of increasing the priority by two levels, and then the running priority of the long-link task on the controller node will maintain the original design of increasing the running priority by one level. If it is no longer possible to achieve T(new total) ≤ T(target) after increasing the priority by two levels, then further upgrades will be made until T(new total) > T(target).

[0053] In this embodiment, a gradual increase and reverse rollback adjustment strategy is adopted to avoid excessive increase in running priority and minimize the impact on other system tasks.

[0054] As an optional embodiment, the method further includes: Step b1: After comparing the new total data execution time with the target data execution time, if the new total data execution time is greater than the target data execution time, and there is a reference controller node whose latest priority for long-link tasks is the highest level, then the execution priority of long-link tasks in the reference controller node will no longer participate in the adjustment of increasing the preset level value. Here, the reference controller node is any controller node.

[0055] Optionally, if after the priority upgrade, T(total) > T(target) and the latest priority of the long link task in any reference controller node, such as the central computing controller node, is the highest level, then the running priority of the long link task in that controller node will no longer be increased. Only other controller nodes that have not reached the highest level will be adjusted to avoid ineffective adjustments.

[0056] As an optional embodiment, the method further includes: Step c1: After comparing the new total data execution time with the target data execution time, if the new total data execution time is greater than the target data execution time, and the latest priority of the long-link task among all subsequent unexecuted controller nodes is the highest level, then the latest priority is used as the global priority configuration for the long-link task.

[0057] Optionally, if during the upgrade process, if T(total) > T(target) and the latest priority of long-link tasks in all subsequent unexecuted controller nodes is the highest level with no further room for improvement, then the current running priority of all long-link tasks in all controllers will be maintained and will no longer participate in priority adjustment. Even if T(new total) ≤ T(target) is not achieved, the subsequent steps will be executed according to the current running priority without interrupting the task flow.

[0058] In this embodiment, a fallback protection mechanism is set up to ensure that long-link tasks are executed first, even if the system is fully loaded and there is no room for optimization. This ensures driving safety, prevents the system from getting stuck in an infinite loop due to priority adjustment, and improves the stability of the operating system.

[0059] This embodiment also provides a time compensation device for long-link tasks across controllers, which is used to implement the above embodiments and preferred embodiments; details already described will not be repeated. As used below, the term "module" can be a combination of software and / or hardware that implements a predetermined function. Although the devices described in the following embodiments are preferably implemented in software, hardware implementations, or a combination of software and hardware, are also possible and contemplated.

[0060] This embodiment provides a time compensation device for long-link tasks across controllers, such as... Figure 5 As shown, it includes: The acquisition module 501 is used to acquire the long-link task that the vehicle is currently waiting to execute and the controller nodes that it depends on to complete the long-link task. The determination module 502 is used to determine the total data execution time of long-link tasks based on the current execution status of the controller node; The comparison module 503 is used to compare the total data execution time with the data execution target time of the long link task to obtain the comparison result, wherein the data execution target time is the highest time corresponding to the completion of the long link task; The adjustment module 504 is used to adjust the running priority of the long link task in each controller node that has not been executed in the subsequent process if the comparison result is that the total data running time is greater than the target data running time, and reduce the running time of the long link task based on the adjusted running priority.

[0061] In this embodiment, the system obtains the long-link task currently to be executed by the vehicle and the controller nodes required to complete the long-link task. Then, based on the current execution status of the controller nodes, it determines the total data execution time of the long-link task. The system then compares the total data execution time with the target data execution time of the long-link task in a globally coordinated manner. Based on the comparison results, the system adjusts the execution priority of the long-link task in each controller node that has not yet been executed. Based on the adjusted execution priority, the system reduces the execution time of the long-link task. This adjustment of execution priority only applies to the long-link task currently to be executed, without consuming additional computing power or affecting other tasks in the system. This results in more efficient resource utilization, solves the problems of inconsistent priorities, uncontrollable time, and large jitter in long-link tasks across controllers, avoids functional failures such as slow braking and delayed headlight flashing, and achieves end-to-end time controllability.

[0062] In this embodiment of the application, the determining module 502 is used to determine the type of controller node based on business requirements; based on the type, obtain controller nodes with a fixed time and controller nodes with an uncertain time; obtain the basic running time and waiting running time of long-link tasks in controller nodes with uncertain time, wherein the waiting running time is related to the running priority of long-link tasks in controller nodes with uncertain time; and obtain the total data running time based on the fixed time corresponding to the controller node with a fixed time, the basic running time and waiting running time of long-link tasks in controller nodes with uncertain time.

[0063] In this embodiment, the determining module 502 is used to sum the basic running time and the waiting running time to obtain the running time corresponding to the controller node with uncertain time; and to obtain the total data running time by adding the running time corresponding to the controller node with fixed time and uncertain time.

[0064] In this embodiment, the adjustment module 504 is used to gradually increase the running priority of the long-link task by a preset level value, and based on the latest running priority after increasing the preset level value a preset number of times, reduce the running time of the long-link task to obtain a new total data running time; compare the new total data running time with the target data running time, and if the new total data running time is less than or equal to the target data running time, obtain the execution order of the controller node when the long-link task is completed; based on the execution order, gradually reduce the latest running priority of the long-link task in the controller node from back to front, and obtain the global priority configuration of the long-link task under the premise that the new total data running time is less than or equal to the target data running time.

[0065] In this embodiment of the application, the device further includes: The first setting module is used to compare the new total data running time with the data running target time. If the new total data running time is greater than the data running target time, and there is a reference controller node whose latest priority is the highest level, then the running priority of the long link task in the reference controller node will no longer participate in the adjustment of increasing the preset level value. Here, the reference controller node is any controller node.

[0066] In this embodiment of the application, the device further includes: The second setting module is used to configure the latest priority as the global priority of the long-link task after comparing the new total data execution time with the target data execution time. If the new total data execution time is greater than the target data execution time, and the latest priority of the long-link task among all subsequent unexecuted controller nodes is the highest level, then the latest priority is used as the global priority configuration of the long-link task.

[0067] In this embodiment of the application, the device further includes: The maintenance module is used to maintain the running priority of long-link tasks in each controller node if the comparison result shows that the total data running time is less than or equal to the data running target time.

[0068] Figure 6 The diagram shows a structural schematic of an embodiment of the computer device of this application. The specific embodiments of this application do not limit the specific implementation of the computer device.

[0069] like Figure 6 As shown, the computer device may include: a processor 602, a communications interface 604, a memory 606, and a communications bus 608.

[0070] The processor 602, communication interface 604, and memory 606 communicate with each other via communication bus 608. Communication interface 604 is used to communicate with other network elements, such as clients or other servers. Processor 602 executes program 610, specifically performing the relevant steps in the above-described embodiment of the method for estimating the driving performance and power generation capacity of the motor.

[0071] Specifically, program 610 may include program code, which includes computer-executable instructions.

[0072] Processor 602 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application. The computer device includes one or more processors, which may be processors of the same type, such as one or more CPUs; or they may be processors of different types, such as one or more CPUs and one or more ASICs.

[0073] Memory 606 is used to store program 610. Memory 606 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0074] This application also provides a vehicle, such as... Figure 7 , Figure 7 This is a structural block diagram of a vehicle provided in an optional embodiment of this disclosure, such as... Figure 7 As shown, the vehicle includes one or more processors 10, memory 20, and interfaces for connecting the components, including high-speed interfaces and low-speed interfaces. The components communicate with each other via different buses and can be mounted on a common motherboard or otherwise installed as needed. The processors can process instructions executed within the computer device, including instructions stored in or on memory to display graphical information of a GUI on an external input / output device (such as a display device coupled to the interface). In some alternative implementations, multiple processors and / or multiple buses can be used with multiple memories and multiple memory modules, if desired. Similarly, multiple computer devices can be connected, each providing some of the necessary operations (e.g., as a server array, a group of blade servers, or a multiprocessor system). Figure 7 Take a processor 10 as an example.

[0075] Processor 10 may be a central processing unit, a network processor, or a combination thereof. Processor 10 may further include a hardware chip. The hardware chip may be an application-specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The programmable logic device may be a complex programmable logic device (CAMP), a field-programmable gate array (FPGA), a general-purpose array logic (GDA), or any combination thereof.

[0076] The memory 20 stores instructions executable by at least one processor 10 to cause at least one processor 10 to perform the method shown in the above embodiments.

[0077] The memory 20 may include a program storage area and a data storage area. The program storage area may store the operating system and applications required for at least one function; the data storage area may store data created based on the use of the computer device. Furthermore, the memory 20 may include high-speed random access memory and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some alternative embodiments, the memory 20 may optionally include memory remotely located relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0078] The memory 20 may include volatile memory, such as random access memory; the memory may also include non-volatile memory, such as flash memory, hard disk or solid-state drive; the memory 20 may also include a combination of the above types of memory.

[0079] The computer device also includes a communication interface 30 for communicating with other devices or communication networks.

[0080] This application also provides a computer-readable storage medium. The methods described in this application can be implemented in hardware or firmware, or implemented as recordable on a storage medium, or implemented as computer code downloaded over a network and originally stored on a remote storage medium or a non-transitory machine-readable storage medium and subsequently stored on a local storage medium. Thus, the methods described herein can be processed by software stored on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. The storage medium can be a magnetic disk, optical disk, read-only memory, random access memory, flash memory, hard disk, or solid-state drive, etc.; further, the storage medium can also include combinations of the above types of memory. It is understood that computers, processors, microprocessor controllers, or programmable hardware include storage components capable of storing or receiving software or computer code. When the software or computer code is accessed and executed by the computer, processor, or hardware, the methods shown in the above embodiments are implemented.

[0081] Numerous specific details are set forth in the specification provided herein. However, it will be understood that embodiments of this application may be practiced without these specific details. Similarly, for the purpose of simplification and aiding understanding of one or more aspects of the invention, in the above description of exemplary embodiments of this application, various features of the embodiments are sometimes grouped together in a single embodiment, figure, or description thereof. The claims, which follow the detailed description, are hereby expressly incorporated into that detailed description, wherein each claim itself is a separate embodiment of this application.

[0082] Those skilled in the art will understand that the modules in the device of the embodiment can be adaptively changed and placed in one or more devices different from that embodiment. Modules, units, or components in the embodiment can be combined into a single module, unit, or component, and further, they can be divided into multiple sub-modules, sub-units, or sub-components, except that at least some of such features and / or processes or units are mutually exclusive.

[0083] It should be noted that the above embodiments are illustrative of this application and not restrictive, and those skilled in the art can devise alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses should not be construed as limiting the claims. The word "comprising" does not exclude the presence of elements or steps not listed in the claims. The word "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. This application can be implemented by means of hardware comprising several different elements and by means of a suitably programmed computer. In the unit claims enumerating several means, several of these means may be embodied by the same item of hardware. The use of the words first, second, and third, etc., does not indicate any order. These words can be interpreted as names. The steps in the above embodiments, unless otherwise specified, should not be construed as limiting the order of execution.

Claims

1. A method for time compensation of long link tasks across controllers, the method comprising: The method includes: Obtain the long-link task currently pending execution of the vehicle and the controller nodes that the vehicle depends on to complete the long-link task; Based on the current execution state of the controller node, determine the total data execution time of the long-link task; The total data execution time is compared with the target data execution time of the long-link task to obtain a comparison result, wherein the target data execution time is the maximum time corresponding to the completion of the long-link task; If the comparison result shows that the total data execution time is greater than the target data execution time, then the execution priority of the long-link task in each of the subsequent unexecuted controller nodes is adjusted, and the execution time of the long-link task is reduced based on the adjusted execution priority.

2. The method according to claim 1, characterized in that, Determining the total data execution time of the long-link task based on the current execution state of the controller node includes: The type of the controller node is determined based on business requirements; Based on the aforementioned types, controller nodes with deterministic times and controller nodes with indeterminate times are obtained; Obtain the base runtime and waiting runtime of the long-link task in the controller node at the uncertain time, wherein the waiting runtime is related to the running priority of the long-link task in the controller node at the uncertain time; The total data execution time is obtained based on the fixed time corresponding to the controller node with the determined time, the basic running time and waiting running time of the long-link task in the controller node with the uncertain time.

3. The method according to claim 2, characterized in that, The total data execution time is obtained by combining the fixed time corresponding to the controller node with the determined time, the base execution time and waiting execution time of the long-link task in the controller node with the uncertain time, and the fixed time corresponding to the fixed time. The base running time and the waiting running time are summed to obtain the running time corresponding to the controller node with the uncertain time. The total data execution time is obtained by adding the running time corresponding to the controller node at the fixed time and the uncertain time.

4. The method according to claim 1, characterized in that, The adjustment of the execution priority of the long-link task in each of the subsequently unexecuted controller nodes includes: The running priority of the long-link task is gradually increased by a preset level value, and the running time of the long-link task is reduced based on the latest running priority after the preset level value is increased a preset number of times, so as to obtain a new total data running time. The new total data execution time is compared with the target data execution time. If the new total data execution time is less than or equal to the target data execution time, the execution order of the controller node when the long link task is completed is obtained. Based on the execution order, the latest running priority of the long-link task in the controller node is gradually reduced from back to front. Under the premise that the total running time of the new data is less than or equal to the target running time of the data, the global priority configuration of the long-link task is obtained.

5. The method according to claim 4, characterized in that, After comparing the new total data execution time with the target data execution time, the method further includes: If the total duration of the new data operation is greater than the target duration of the data operation, and the latest priority of the long-link task in the reference controller node is the highest level, then the operation priority of the long-link task in the reference controller node will no longer participate in the adjustment of increasing the preset level value, wherein the reference controller node is any of the controller nodes.

6. The method according to claim 4, characterized in that, After comparing the new total data execution time with the target data execution time, the method further includes: If the total duration of the new data execution exceeds the target duration of the data execution, and the latest priority of the long-link task among all subsequent unexecuted controller nodes is the highest level, then the latest priority will be used as the global priority configuration for the long-link task.

7. The method according to claim 1, characterized in that, The method further includes: If the comparison result shows that the total data execution time is less than or equal to the target data execution time, then the execution priority of the long-link task in each of the controller nodes is maintained.

8. A time compensation device for long-link tasks across controllers, characterized in that, The device includes: The acquisition module is used to acquire the long-link task that the vehicle is currently waiting to execute and the controller nodes that it depends on to complete the long-link task. The determination module is used to determine the total data execution time of the long-link task based on the current execution state of the controller node; The comparison module is used to compare the total data execution time with the data execution target time of the long-link task to obtain a comparison result, wherein the data execution target time is the highest time corresponding to the completion of the long-link task; An adjustment module is configured to, if the comparison result indicates that the total data execution time is greater than the target data execution time, adjust the execution priority of the long-link task in each of the subsequently unexecuted controller nodes, and reduce the execution time of the long-link task based on the adjusted execution priority.

9. A computer device, characterized in that, include: A memory and a processor are communicatively connected, the memory storing computer instructions, and the processor executing the computer instructions to perform the time compensation method for long-link tasks across controllers as described in any one of claims 1 to 7.

10. A vehicle, characterized in that, include: A memory, a processor, and a computer program stored in the memory and executable on the processor, the processor executing the program to implement the time compensation method for long-link tasks across controllers as described in any one of claims 1 to 7.

Images