WO2023109338A1

WO2023109338A1 - Load control method and apparatus for kernel, and computer-readable storage medium

Info

Publication number: WO2023109338A1
Application number: PCT/CN2022/128718
Authority: WO
Inventors: 徐阳
Original assignee: 中兴通讯股份有限公司
Priority date: 2021-12-14
Filing date: 2022-10-31
Publication date: 2023-06-22
Also published as: CN116263705A

Abstract

A load control method and apparatus for a kernel, and a computer-readable storage medium. The method comprises: acquiring a first time of a thread, and acquiring a second time of the thread, wherein the first time is a CPU time consumed by circularly executing the thread in a corresponding kernel, and the second time is a CPU time consumed by processing an effective service when the thread is circularly executed in the corresponding kernel (100); according to the first time and the second time of the thread, determining a CPU occupancy rate of the kernel corresponding to the thread (200); and performing load control on a plurality of kernels according to the CPU occupancy rates of the plurality of kernels (300).

Description

Kernel load control method and device, computer-readable storage medium

Cross References to Related Applications

This application is based on a Chinese patent application with application number 202111528005.8 and a filing date of December 14, 2021, and claims the priority of this Chinese patent application. The entire content of this Chinese patent application is hereby incorporated by reference into this application.

technical field

The embodiments of the present application relate to the field of computer technology, and in particular, to a method and device for controlling kernel load, and a computer-readable storage medium.

Background technique

In the computer field, with the emergence of multi-core CPUs, for high-throughput parallel software processing, the general practice is to share the business load on multiple threads for parallel processing, and each parallel execution thread is bound to a separate Core, so that multiple cores work in parallel to improve the overall processing capability of the device. Based on the above setting method, only the user mode program of this business runs on a specific kernel, and the CPU usage rate of the kernel determined according to the relevant calculation method in Linux is always displayed as 100%, but in the actual scene , the actual load of the business program is usually not kept at a constant 100%, and may even be 0, so the obtained kernel overhead is inaccurate, making the upper system unable to accurately implement load distribution, affecting device performance.

Contents of the invention

The following is an overview of the topics described in detail in this article. This summary is not intended to limit the scope of the claims.

Embodiments of the present application provide a kernel load control method and device, and a computer-readable storage medium.

In the first aspect, the embodiment of the present application provides a method for controlling the load of a kernel. There are multiple kernels, and the kernels are individually bound to threads. The method includes: obtaining the first time of the thread, and obtaining the first time of the thread. The second time of the thread, the first time is the CPU time consumed by the thread in the corresponding kernel, and the second time is the CPU time consumed by the thread in the corresponding kernel In this case, process the CPU time consumed by effective services; determine the CPU occupancy rate of the core corresponding to the thread according to the first time and the second time of the thread; The CPU usage performs load control on multiple cores.

In the second aspect, the embodiment of the present application also provides a load control device, including: a memory, a processor, and a computer program stored in the memory and operable on the processor, and the processor implements the computer program when executing the computer program. The method for controlling the load of the kernel as described in the first aspect above.

In a third aspect, the embodiment of the present application further provides a computer-readable storage medium, storing computer-executable instructions, and the computer-executable instructions are used to execute the method for controlling the load of a kernel as described in the first aspect above.

Additional features and advantages of the application will be set forth in the description which follows, and, in part, will be obvious from the description, or may be learned by practice of the application. The objectives and other advantages of the application will be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.

Description of drawings

The accompanying drawings are used to provide a further understanding of the technical solution of the present application, and constitute a part of the specification, and are used together with the embodiments of the present application to explain the technical solution of the present application, and do not constitute a limitation to the technical solution of the present application.

Fig. 1 is a flow chart of the load control method of the kernel provided by one embodiment of the present application;

Fig. 2 is a flow chart of obtaining the second time of the thread in the load control method of the kernel provided by one embodiment of the present application;

FIG. 3 is a flow chart of obtaining a second time of a thread according to an effective service in a load control method of the kernel provided by an embodiment of the present application;

Fig. 4 is a flow chart of obtaining the forwarding rate of the thread at the first time in the load control method of the kernel provided by an embodiment of the present application;

FIG. 5 is a flow chart of obtaining a fourth time of a thread in a kernel load control method provided by an embodiment of the present application;

FIG. 6 is a flow chart of determining the CPU usage of the kernel in a method for controlling the load of the kernel provided by an embodiment of the present application;

FIG. 7 is a schematic diagram of a CPU processor provided by an embodiment of the present application;

FIG. 8 is a flow chart of performing load control on multiple cores in a core load control method provided by an embodiment of the present application;

FIG. 9 is a schematic diagram of an execution flow of a kernel load control method provided by an embodiment of the present application;

FIG. 10 is a flow chart after determining the CPU usage of the kernel in the load control method of the kernel provided by an embodiment of the present application;

FIG. 11 is a schematic diagram of the execution flow of a kernel load control method provided by another embodiment of the present application;

Fig. 12 is a schematic diagram of a load control device provided by an embodiment of the present application.

Detailed ways

In order to make the purpose, technical solution and advantages of the present application clearer, the present application will be further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the embodiments described here are only used to explain the present application, not to limit the present application.

It should be noted that although the functional modules are divided in the schematic diagram of the device, and the logical sequence is shown in the flowchart, in some cases, it can be executed in a different order than the module division in the device or the flowchart in the flowchart. steps shown or described. The terms "first", "second" and the like in the specification and claims and the above drawings are used to distinguish similar objects, and not necessarily used to describe a specific sequence or sequence.

The application provides a kernel load control method and device, and a computer-readable storage medium. For each thread, by obtaining the first time and the second time of the thread, it is possible to show the actual cyclic execution of the thread in the bound kernel. According to the first time and the second time of the thread, the CPU occupancy rate of the core bound by the thread is accurately known. Compared with related technologies, based on the accurately determined CPU occupancy rate of multiple cores, it is convenient for the upper system to make full use of multiple cores. The parallelism of the kernel architecture realizes multi-core load balancing control and improves device performance.

The embodiments of the present application will be further described below in conjunction with the accompanying drawings.

As shown in Figure 1, Figure 1 is a flowchart of a method for controlling the load of a kernel provided by an embodiment of the present application, wherein there are multiple kernels, and the kernels are individually bound to threads, and the method for controlling the load of the kernel includes but is not limited to step S100 to S300.

Step S100: obtain the first time of the thread, and the second time of obtaining the thread, the first time is the CPU time consumed by the thread in the corresponding core, and the second time is the thread in the corresponding kernel. Next, the CPU time consumed by processing valid services.

In an embodiment, for each thread, by obtaining the first time and the second time of the thread, the actual overhead of the thread's loop execution in the bound core can be displayed. Since each core is bound to a thread independently, the application A thread running in an endless loop, so the relevant CPU time occupied by the thread in the kernel is equivalent to the relevant CPU time required by the kernel, so that it can be determined according to the obtained first time and second time in subsequent steps The CPU usage of the kernel.

It should be noted that, for threads in different cores, the effective services they respectively process may be different, and the number of cores is determined according to the device, which is not limited in this embodiment.

It can be understood that since the thread runs in an endless loop in the exclusively bound core, the first time and the second time of the thread are actually obtained by superimposing the time consumed by each cycle, so in determining the first time of each cycle After the corresponding components of the first time and the second time, that is, after determining that the thread is in the corresponding core, the CPU time consumed by executing a cycle and the thread is executed in the corresponding core in the case of a cycle, after the CPU time consumed by processing valid services , then the first time and the second time of the thread can be further determined, and an embodiment will be given below for illustration.

In the example of FIG. 2 , the "obtaining the second time of the thread" in step S100 includes but not limited to steps S110 to S120.

Step S110: Obtain the feedback result of processing the business of each instance when the thread executes a cycle in the kernel;

Step S120: According to all feedback results and preset service evaluation conditions, determine valid services from each example service;

Step S130: Obtain the second time of the thread according to the effective service.

In one embodiment, since each instance service can feed back the corresponding result after execution, it is possible to determine the effective service from each instance service based on the corresponding relationship between the feedback result and the preset service evaluation conditions, and further according to The CPU time consumed by the effective service is processed by the active service acquisition thread in the case of cyclic execution in the corresponding core, so the second time of the thread can be acquired accurately and reliably.

It should be noted that the preset service evaluation conditions can be set according to different application scenarios, and there is no uniform standard. For example, if there is time for processing packets in a thread, it can be considered as valuable time for the entire device. That is, the effective time, if there is no message processing in the thread, even if it calls the driver to receive or send a package (actually does not receive or send a package), it is considered to be idle time, and correspondingly, it is judged that there is a processing message The conditions of the time or situation are the preset business evaluation conditions.

In one embodiment, the instance business can be any business under the thread, or any business related to the thread, as long as it is executed in the thread, it can be regarded as the instance business processed by the thread; in addition, the form of the feedback result is not It is not limited, and may be represented by a numerical value or a symbol, but no matter what the form is, as long as it corresponds to the preset service evaluation condition.

In the example of FIG. 3 , step S130 includes but not limited to steps S131 to S134.

Step S131: According to the effective service, determine the effective functional unit for executing the effective service from the thread;

Step S132: Obtain the first initial time and the first end time when the effective functional unit executes the effective business;

Step S133: subtracting the first initial time from the first end time to obtain the third time;

Step S134: Obtain the added value of all the third times to obtain the second time of the thread.

In one embodiment, each instance service is executed by a corresponding functional unit. By determining the effective service, the effective functional unit used to execute the effective service can be determined from the thread, and the execution time of the effective functional unit is the effective processing time. Therefore, by obtaining the first initial moment and the first end moment when the effective functional unit executes the effective service, the effective time for the thread to execute a cycle can be determined, and finally the second time of the thread can be obtained by superimposing the effective time of each cycle. Time, it can be seen that the second time obtained based on the method of this embodiment is accumulated based on the effective time of each cycle determined separately, so the accuracy is high, and it can well represent the thread in the corresponding core. CPU time consumed by processing valid services in the case of mid-cycle execution.

It can be understood that, in the process of executing each loop of the thread, the first initial moment and the first end moment when the effective functional unit executes the effective service may be the same or different, and the correspondingly determined third time may also be can be different, which is not limited in this embodiment.

In the example of FIG. 4 , the "acquiring the first time of the thread" in step S100 includes but not limited to steps S140 to S150.

Step S140: Obtain the fourth time of the thread, the fourth time is the CPU time consumed by the thread executing a cycle in the kernel;

Step S150: add up all the fourth times to obtain the first time of the thread.

In one embodiment, the first time of the thread can be accurately obtained by obtaining the CPU time consumed by each cycle executed by the thread in the kernel, determining the fourth time of the thread, and then superimposing the CPU time consumed by all cycles.

It can be understood that, in the process of executing each loop of the thread, the CPU time consumed by each thread may be the same or different, and the correspondingly determined fourth time may also be different, which is not shown in this embodiment. limit.

In the example of FIG. 5 , step S140 includes but not limited to steps S141 to S142.

Step S141: Obtain the second initial moment and the second end moment when the thread executes a cycle in the kernel;

Step S142: Subtract the second initial time from the second end time to obtain a fourth time.

In one embodiment, since the thread will execute in a loop after completing the initialization, and then call each execution function body repeatedly, so based on each execution function body, the second initial moment and the second end moment when the thread executes a cycle in the kernel can be determined , and then by obtaining the difference between the second end time and the second initial time, the fourth time is obtained through precise calculation.

Step S200: Determine the CPU usage of the core corresponding to the thread according to the first time and the second time of the thread.

In one embodiment, since the thread is executed in a separate cycle in the kernel, the execution parameter of the thread is equivalent to the execution parameter of the kernel. Therefore, the thread corresponding to the thread can be further accurately determined according to the first time and the second time of the thread. Compared with related technologies, the CPU usage rate of the kernel does not always appear as 100% of the calculated CPU usage rate of the kernel, and the calculation result is more accurate and reliable.

In the example of FIG. 6 , step S200 includes but not limited to steps S210 to S220.

Step S210: when the first time is greater than the preset threshold time, divide the second time by the first time to obtain the CPU usage rate of the thread;

Step S220: Determine the CPU usage rate of the kernel as the CPU usage rate of the thread.

In one embodiment, since the core is bound to the thread separately, when the CPU time consumed by the cyclic execution of the thread in the corresponding core exceeds the preset threshold time, the CPU time of the thread is obtained by dividing the second time by the first time. Occupancy rate, where the purpose of setting the preset threshold time is to ensure that the calculated first time can meet the duration requirement, that is, the number of thread loop executions corresponding to the first time should reach the corresponding value, so as not to cause calculation due to too few samples The result is inaccurate, reducing the calculation error.

It can be understood that the preset threshold time can be set correspondingly according to different scenarios, which is not limited in this embodiment.

It should be noted that the calculation method in step S210 is only used to characterize the basic principle of calculating the CPU usage of the thread without any limitation. In the application scenario, the result of dividing the first time by the second time can be Add the set coefficient to multiply, for example, multiply the original 0.5 by 100 to get 50, then the CPU usage of the thread is 50, or directly use the original 0.5 as the CPU usage of the thread, only need to ensure its The calculation principle is the same interface, which is not limited in this embodiment.

Step S300: Perform load control on multiple cores according to the CPU usage rates of the multiple cores.

In an embodiment, for each thread, by obtaining the first time and the second time of the thread, the actual cost of the thread's loop execution in the bound core can be displayed, and then according to the first time and the second time of the thread, Accurately know the CPU occupancy rate of the thread-bound cores. Compared with related technologies, based on the accurately determined CPU occupancy rates of multiple cores, it is convenient for the upper system to make full use of the parallelism of the multi-core architecture, realize multi-core load balancing control, and improve device performance.

It should be noted that by binding threads to a fixed kernel, task switching and process refreshing can be reduced, thereby reducing related overhead and achieving the purpose of improving application performance. In application scenarios, this embodiment is not only applicable to native Linux and The data plane development kit (Data Plane Development Kit, DPDK) provided by Intel, etc., can also be applied to other similar exclusive core application scenarios, such as application scenarios that can be used for storage processing, or can also be used for computing software. The overhead of each module in the total CPU is not limited in this embodiment.

Examples are given below to illustrate the working principles and processes of the above-mentioned embodiments.

Example one:

As shown in FIG. 7 , FIG. 7 is a schematic diagram of a CPU processor provided by an embodiment of the present application.

In the example of FIG. 7, the CPU processor includes 4 cores, wherein CORE0 is a shared core, and CORE1 to CORE3 are exclusive cores; the APP program starts a main thread and three slave threads, and the main thread is bound to CORE0, Share the core CORE0 with the operating system, perform non-infinite loop execution, and be able to complete some control-related work. The CPU usage calculation of CORE0 can refer to the standard calculation method in related technologies, so I won’t go into details here; three slave threads perform APP For the business processing of the program, these three slave threads are respectively bound to CORE1 to CORE3 to run in an endless loop. In this case, the CPU usage result obtained by using the standard calculation method in related technologies for these three COREs is 100%. , in order to calculate the actual overhead of the three COREs, it is necessary to use the calculation method of the embodiment of the present application to calculate the CPU usage.

In the example of FIG. 8 , steps S310 to S320 are also included after step S200 .

Step S310: Determine the load weight of each core according to the CPU usage of multiple cores;

Step S320: For each core, assign instance tasks corresponding to the load weight to the core.

In one embodiment, after determining the CPU occupancy rate of multiple cores, the proportion of the CPU occupancy rate of each core can be determined, and the proportion is the load weight of each core, which represents the load capacity that each core can bear. In this case, the instance tasks corresponding to the load weight are assigned to the core to realize the adjustment of the load balancing strategy, so as to achieve better load sharing, so that the overall device performance is better improved, and the actual load of a single core is avoided. A situation where its load capacity degrades overall equipment performance.

Example two:

As shown in FIG. 9 , FIG. 9 is a schematic diagram of an execution flow of a kernel load control method provided by an embodiment of the present application.

In the example in Figure 9, the corresponding system architecture can be vEPC, including a CPU, the CPU includes 4 cores, where CORE0 is a shared core, and CORE1 to CORE3 are exclusive cores; the APP program starts a main thread and three slaves Thread, the main thread is bound to CORE0, shares core CORE0 with the operating system, performs non-infinite loop execution, and can complete some control-related work. The CPU usage calculation of CORE0 can refer to the standard calculation method in related technologies; three The slave threads perform the business processing of the APP program, and these three slave threads are respectively bound to CORE1 to CORE3 to run in an endless loop.

After the CPU usage of CORE1 to CORE3 is calculated, the main thread can read the result, store the result in the local memory, and report the result to the control plane through the corresponding transmission channel, and the load balancer in the control plane The load weight of each instance is formed according to the CPU overhead of the core bound to each instance, and then the user traffic is allocated to different instances according to the load weight, so as to complete the load control and sharing of the instances, so that CORE1 to CORE3 can coordinate and balance the work, so that Equipment performance is optimal.

It should be noted that the CPU overhead of uploading the kernel through the transmission channel can be periodic. Correspondingly, the allocation of user traffic to different instances according to the load weight can also be periodic, so as to achieve more stable and reliable load balancing control Effect.

In the example of FIG. 10, step S300 includes but is not limited to step S400.

Step S400: When the CPU usage of the core exceeds the preset overhead threshold, an alarm prompt message is issued.

In one embodiment, a preset overhead threshold can be preset according to the kernel component performance, application environment and other parameters, representing the upper limit of the overhead that the kernel can bear. When the calculated CPU usage of the kernel exceeds the preset overhead threshold, It means that the actual overhead of the kernel at this time has exceeded the upper limit of the overhead that it can bear, and there is a dangerous situation for the kernel. Therefore, by setting an alarm prompt message in this scenario, it can remind external personnel of the actual usage of the kernel. In order to adjust and control the kernel.

Example three:

As shown in FIG. 11 , FIG. 11 is a schematic diagram of an execution flow of a kernel load control method provided by another embodiment of the present application.

In the example shown in Figure 11, the corresponding system architecture can be vEPC, including a CPU, which includes 4 cores, where CORE0 is a shared core, and CORE1 to CORE3 are exclusive cores; the APP program starts a main thread and three slave cores. Thread, the main thread is bound to CORE0, shares core CORE0 with the operating system, performs non-infinite loop execution, and can complete some control-related work. The CPU usage calculation of CORE0 can refer to the standard calculation method in related technologies; three The slave threads perform the business processing of the APP program, and these three slave threads are respectively bound to CORE1 to CORE3 to run in an endless loop.

The setup and calculation process includes the following steps:

Step 1, set CORE1 to CORE3 as exclusive cores, which can be done but not limited to by modifying the grub file. Since this method is the basic content of linux, it will not be described in detail;

Step 2, bind threads 1 to 3 to CORE1 to CORE3 respectively, which can be completed by using related commands, such as taskset-cp cpu-list pid, or by calling the interface of the operating system in the program, which is not mentioned here to repeat;

Step 3, determining the evaluation standard, wherein, in this embodiment, the evaluation is performed based on the message forwarding process of the user plane of the vEPC. Then, if there is time for processing packets in the program, it is considered as valuable time for vEPC. If there is no packet processing in the program, even if it calls the driver to receive or send packets (actually no packets are received or sent) , which is also considered to be idle time;

Step 4, implement the method of this embodiment, calculate required value, take from thread 1 as example, only need to calculate these two times of second time Usedtick and first time Alltick, then can calculate the CPU of core Occupancy rate Cpurate, the formula is as follows:

Cpurate = Usedtick*100/Alltick;

Among them, the calculation considerations for Alltick:

After the thread is initialized, it will always execute in a while loop. In this loop, each execution function body will be called repeatedly. Therefore, a system time tick1 is taken at the beginning of a loop, and a system time tick2 is taken at the end of the loop. Then this The difference between the two times is the total time of this cycle, and the formula is as follows:

DivTick=tick2-tick1;

Then add up the total duration of the thread's single execution loop to get Alltick, namely:

Alltick+=DivTick;

Considerations for the calculation of Usedtick:

All execution functional units of a thread have a return value, which indicates that effective message processing or other timing processing has been executed, and it is still a no-op. Therefore, a system time tick3 can be taken at the initial stage of functional unit execution, and a tick3 at the end of execution. System time tick4, and judge whether the return value ret1 indicates a valid action, if it is valid, add the difference to Usedtick, the formula is as follows:

Usedtick+=tick4-tick3;

Step 5, set a timing duration (such as 1s), and judge at the last moment of one of the while loops, if the timing duration is exceeded, the calculation of Usedtick can be performed, and then the CPUrate of thread 1 can be calculated, and the CPU rate of thread 1 can be calculated. It is exclusive to CORE1, so the Cpurate is the CPU usage of CORE1;

Step 6: Store the calculated CORE overhead in the local memory, and judge with the preset overhead threshold to decide whether to send an alarm to the background, or report the CPU usage of CORE1 to 3 to the background through the transmission channel to show.

In addition, referring to FIG. 12 , an embodiment of the present application also provides a load control device 100, the load control device 100 includes: a memory 110, a processor 120, and an Computer program.

The processor 120 and the memory 110 may be connected through a bus or in other ways.

The non-transitory software programs and instructions required to realize the load control method of the core of the above-mentioned embodiments are stored in the memory 110, and when executed by the processor 120, the load control methods of the core of the above-mentioned embodiments are executed, for example, the above Described method steps S100 to S300 in Fig. 1, method steps S110 to S130 in Fig. 2, method steps S131 to S134 in Fig. 3, method steps S140 to S150 in Fig. 4, method steps S141 to S150 in Fig. 5 S142, method steps S210 to S220 in FIG. 6 , method steps S310 to S320 in FIG. 8 or method step S400 in FIG. 10 .

The device embodiments described above are only illustrative, and the units described as separate components may or may not be physically separated, that is, they may be located in one place, or may be distributed to multiple network units. Part or all of the modules can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, an embodiment of the present application also provides a computer-readable storage medium, the computer-readable storage medium stores computer-executable instructions, and the computer-executable instructions are executed by a processor 120 or a controller, for example, by Execution by a processor 120 in the above-mentioned device embodiment can make the above-mentioned processor 120 execute the load control method of the kernel in the above-mentioned embodiment, for example, execute the method steps S100 to S300 in FIG. 1 described above, and the method in FIG. 2 Method steps S110 to S130, method steps S131 to S134 among Fig. 3, method steps S140 to S150 among Fig. 4, method steps S141 to S142 among Fig. 5, method steps S210 to S220 among Fig. 6, Fig. 8 Method steps S310 to S320 or method step S400 in FIG. 10 .

The embodiment of the present application includes: the first time to obtain the thread, and the second time to obtain the thread, the first time is the CPU time consumed by the thread in the corresponding kernel, and the loop execution is executed, and the second time is the thread in the corresponding kernel. In the case of execution, process the CPU time consumed by effective business; determine the CPU usage of the core corresponding to the thread according to the first time and the second time of the thread; control the load of multiple cores according to the CPU usage of multiple cores . According to the solution provided by the embodiment of this application, for each thread, by obtaining the first time and the second time of the thread, the actual overhead of the thread's loop execution in the bound kernel can be displayed, and then according to the first time and the second time of the thread Second, accurately know the CPU occupancy rate of the thread-bound core. Compared with related technologies, based on the accurately determined CPU occupancy rate of multiple cores, it is convenient for the upper system to make full use of the parallelism of the multi-core architecture to achieve multi-core load balancing. Control and improve equipment performance.

Those skilled in the art can understand that all or some of the steps and systems in the methods disclosed above can be implemented as software, firmware, hardware and an appropriate combination thereof. Some or all of the physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit . Such software may be distributed on computer readable media, which may include computer storage media (or non-transitory media) and communication media (or transitory media). As known to those of ordinary skill in the art, the term computer storage media includes both volatile and nonvolatile media implemented in any method or technology for storage of information, such as computer readable instructions, data structures, program modules, or other data. permanent, removable and non-removable media. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical disk storage, magnetic cartridges, tape, magnetic disk storage or other magnetic storage devices, or can Any other medium used to store desired information and which can be accessed by a computer. Furthermore, as is well known to those of ordinary skill in the art, communication media typically embody computer readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism, and may include any information delivery media .

The above is a description of several implementations of the application, but the application is not limited to the above implementations. Those skilled in the art can also make various equivalent deformations or replacements without violating the spirit of the application. These equivalents Any modification or substitution is included within the scope defined by the claims of the present application.

Claims

A method for controlling the load of a kernel, wherein there are multiple kernels, and the kernels are individually bound to threads, and the method includes:

Acquire the first time of the thread and the second time of the thread, the first time is the CPU time consumed by the thread in the corresponding kernel, and the second time is the When the above-mentioned thread is executed cyclically in the corresponding kernel, the CPU time consumed by processing valid services;

determining the CPU usage of the core corresponding to the thread according to the first time and the second time of the thread;

Perform load control on multiple cores according to the CPU usage of multiple cores.
The load control method of a kernel according to claim 1, wherein said determining the CPU occupancy rate of the kernel corresponding to the thread according to the first time and the second time of the thread includes :

When the first time is greater than the preset threshold time, dividing the second time by the first time to obtain the CPU usage of the thread;

Determine the CPU occupancy rate of the kernel as the CPU occupancy rate of the thread.
The load control method for cores according to claim 1 or 2, wherein the load control of multiple cores according to the CPU occupancy rates of multiple cores includes:

determining the load weight of each of the cores according to the CPU usage of multiple cores;

For each of the kernels, the instance tasks corresponding to the load weights are assigned to the kernels.
The load control method of the kernel according to claim 1, wherein said acquiring the second time of said thread comprises:

Obtain the feedback result of processing each instance business when the thread executes a cycle in the kernel;

determining the effective service from each of the example services according to all the feedback results and preset service evaluation conditions;

Acquire the second time of the thread according to the effective service.
The load control method of the kernel according to claim 4, wherein said obtaining the second time of the thread according to the effective service comprises:

determining an effective functional unit for executing the effective service from the thread according to the effective service;

Obtaining a first initial moment and a first end moment when the effective functional unit executes the effective service;

subtracting the first initial time from the first end time to obtain a third time;

Obtain the added value of all the third times to obtain the second time of the thread.
The load control method of the kernel according to claim 1, wherein said obtaining the first time of said thread comprises:

Obtaining the fourth time of the thread, the fourth time being the CPU time consumed by the thread executing a cycle in the kernel;

All the fourth times are added together to obtain the first time of the thread.
The load control method of the kernel according to claim 6, wherein said acquiring the fourth time of said thread comprises:

Obtaining a second initial moment and a second end moment when the thread executes a cycle in the kernel;

Subtracting the second initial time from the second end time to obtain a fourth time.
The method for controlling the load of a core according to claim 1 or 2, wherein, according to the first time and the second time of the thread, determining the CPU of the core corresponding to the thread After occupancy, it also includes:

When the CPU usage of the kernel exceeds the preset overhead threshold, an alarm prompt message is sent.
A load control device, comprising: a memory, a processor, and a computer program stored on the memory and operable on the processor. When the processor executes the computer program, the computer program described in any one of claims 1 to 8 is realized. The load control method of the kernel described above.
A computer-readable storage medium storing computer-executable instructions, the computer-executable instructions being used to execute the method for controlling the load of a kernel according to any one of claims 1-8.