CN113760374A - Processor binding method and device and electronic equipment - Google Patents
Processor binding method and device and electronic equipment Download PDFInfo
- Publication number
- CN113760374A CN113760374A CN202111002197.9A CN202111002197A CN113760374A CN 113760374 A CN113760374 A CN 113760374A CN 202111002197 A CN202111002197 A CN 202111002197A CN 113760374 A CN113760374 A CN 113760374A
- Authority
- CN
- China
- Prior art keywords
- binding
- layer
- service unit
- core
- core binding
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/4401—Bootstrapping
- G06F9/4403—Processor initialisation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/545—Interprogram communication where tasks reside in different layers, e.g. user- and kernel-space
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application relates to the technical field of computers, in particular to a binding method and a binding device of a processor and electronic equipment, wherein the method comprises the following steps: the system software architecture of the intelligent terminal comprises an application program layer, a system framework layer, a hardware abstraction layer and a Linux kernel layer from top to bottom, and the system software architecture responds to a core binding request triggered by the application program layer or the system framework layer and sends the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation; acquiring hardware parameters of a Linux kernel layer by a binding service unit, and determining at least one processor with binding relation with an application program corresponding to a service unit identifier according to the hardware parameters; notifying the Linux kernel layer of the binding relationship by a binding service unit; therefore, in response to the hardware calling requirement of the application program, the Linux kernel layer calls at least one processor according to the binding relation, so that the running efficiency of the application program is met, and the response speed is improved.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for binding a processor, and an electronic device.
Background
Android (Android) is an operating system according to the open source code of the linnax (Linux) real-time operating system (kernel) (which does not contain commercial operating system (GNU) components), which is mainly used in mobile smart devices. In the prior art, the default of the allocation of a Central Processing Unit (CPU) core is controlled by a bottom kernel, and the bottom kernel generally implements scheduling management of a process by using a general CPU core scheduling policy.
For example, the bottom kernel allocates CPU cores to each service request in the system one by one according to the receiving timing sequence of the service request, so as to implement process scheduling; for another example, the bottom kernel allocates a CPU core to each service request in sequence according to the preset priority of each service request, so as to implement process scheduling.
In general, the default scheduling policy adopted by the android operating system can meet the requirements of the existing process scheduling. However, when a process that a certain service request needs to be called requires high operation efficiency, and a CPU core pre-allocated by a bottom kernel for the process cannot meet the operation efficiency of the called process, the application program corresponding to the process may be jammed and crashed. However, in the prior art, there is no preferable solution to solve the problem that the pre-allocated CPU cannot meet the operation efficiency required by the process.
In summary, a new method needs to be devised to solve the above problems.
Disclosure of Invention
The embodiment of the application provides a binding method and device of a processor and electronic equipment, and aims to solve the problem that a CPU (central processing unit) pre-distributed by a bottom kernel in the prior art cannot meet the operation efficiency required by a process.
The specific technical scheme provided by the application is as follows:
in a first aspect, an embodiment of the present application provides a method for binding a processor, where the method is applied to an intelligent terminal, a system software architecture of the intelligent terminal includes, from top to bottom, an application layer, a system framework layer, a hardware abstraction layer, and a Linux kernel layer, and the method includes:
responding to a core binding request triggered by the application program layer or the system framework layer, and sending the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation;
acquiring hardware parameters of the Linux kernel layer by the core binding service unit, and determining at least one processor having a core binding relationship with an application program corresponding to the service unit identifier according to the hardware parameters;
notifying, by the tieing service unit, the Linux kernel layer of the tieing relationship;
and responding to the hardware calling requirement of the application program, and calling the at least one processor by the Linux kernel layer according to the binding relationship.
In some possible embodiments, the application layer triggers the bind request, including:
if the running state of the application program corresponding to the service unit identifier meets a first preset condition, triggering the core binding request through the application program layer;
the system framework layer triggers the core binding request, and the method comprises the following steps:
and if the system framework layer monitors a process meeting a second preset condition, triggering the core binding request through the system framework layer.
In some possible embodiments, the first preset condition includes that the required resource amount of the application program corresponding to the service unit identifier exceeds a first threshold, and/or the total number of processes included in the application program corresponding to the service unit identifier reaches a second threshold;
the second preset condition comprises that the running speed corresponding to the existing process and/or the existing thread is lower than a third threshold value, and/or the Activity cold start needs to be established.
In some possible embodiments, the sending the binding request to a binding service unit includes:
calling a first core binding service interface contained in the application program layer or calling a second core binding service interface contained in the system framework layer, and sending the core binding request to the core binding service unit;
acquiring the hardware parameters of the Linux kernel layer by the binding service unit, wherein the hardware parameters comprise:
calling a third core binding service interface contained in the core binding service unit, and sending an acquisition request to the hardware abstraction layer, wherein the acquisition request is used for acquiring the hardware parameters of the Linux kernel layer;
calling a fourth binding service interface contained in the hardware abstraction layer according to the acquisition request, acquiring the hardware parameter of the Linux kernel layer, and calling the fourth binding service interface to send the fourth binding service interface to the third binding service interface;
and the core binding service unit receives the hardware parameters through the third core binding service interface.
In some possible embodiments, the determining, according to the hardware parameter, that the application program corresponding to the service unit identifier has a binding relationship includes:
acquiring a preset binding relationship set by the binding service unit, wherein the binding relationship set comprises service unit identifications meeting preset conditions and at least one processor with a binding relationship of application programs corresponding to the service unit identifications;
screening out a binding relationship associated with the application program corresponding to the service unit identifier from the binding relationship set according to the hardware parameter, and determining the at least one processor corresponding to the application program according to the binding relationship.
In some possible embodiments, the notifying, by the tiering service unit, the Linux kernel layer of the tiering relationship includes:
calling a third core binding service interface contained in the core binding service unit, and sending the core binding relationship to a fourth core binding service interface of the hardware abstraction layer;
and calling a fourth core binding service interface contained in the hardware abstraction layer, and sending the core binding relationship to the Linux kernel layer.
In some possible embodiments, before sending the core binding request to a core binding service unit in response to the core binding request triggered by the application layer or the system framework layer, the method further includes:
calling an init daemon by the Linux kernel layer to acquire a configuration file corresponding to the binding service;
and analyzing the configuration file, and loading and initializing the binding service unit.
In some possible embodiments, parsing the configuration file, loading and initializing the binding service unit includes:
analyzing the configuration file, and executing a CPU parameter initializing process through the hardware abstraction layer to obtain the hardware parameters of the Linux kernel layer;
and calling the hardware abstraction layer to perform service type registration to a HwServiceManager, and registering the service type communicated with the binding service unit as a hwbinder service type.
In a second aspect, an embodiment of the present application provides a binding apparatus for a processor, including:
the sending module is used for responding to a core binding request triggered by the application program layer or the system framework layer and sending the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation;
the determining module is used for acquiring the hardware parameters of the Linux kernel layer by the binding service unit and determining at least one processor with a binding relationship with the application program corresponding to the service unit identifier according to the hardware parameters;
the notification module is used for notifying the Linux kernel layer of the binding relationship by the binding service unit;
and the calling module is used for responding to the hardware calling requirement of the application program, and calling the at least one processor by the Linux kernel layer according to the binding relationship.
In some possible embodiments, the application layer triggers the bind request, and the sending module is configured to:
if the running state of the application program corresponding to the service unit identifier meets a first preset condition, triggering the core binding request through the application program layer;
the system framework layer triggers the core binding request, and the sending module is used for:
and if the system framework layer monitors a process meeting a second preset condition, triggering the core binding request through the system framework layer.
In some possible embodiments, the first preset condition includes that the required resource amount of the application program corresponding to the service unit identifier exceeds a first threshold, and/or the total number of processes included in the application program corresponding to the service unit identifier reaches a second threshold;
the second preset condition comprises that the running speed corresponding to the existing process and/or the existing thread is lower than a third threshold value, and/or the Activity cold start needs to be established.
In some possible embodiments, the sending the binding request to a binding service unit, and the sending module is configured to:
calling a first core binding service interface contained in the application program layer or calling a second core binding service interface contained in the system framework layer, and sending the core binding request to the core binding service unit;
the binding service unit acquires the hardware parameters of the Linux kernel layer, and the determining module is used for:
calling a third core binding service interface contained in the core binding service unit, and sending an acquisition request to the hardware abstraction layer, wherein the acquisition request is used for acquiring the hardware parameters of the Linux kernel layer;
calling a fourth binding service interface contained in the hardware abstraction layer according to the acquisition request, acquiring the hardware parameter of the Linux kernel layer, and calling the fourth binding service interface to send the fourth binding service interface to the third binding service interface;
and the core binding service unit receives the hardware parameters through the third core binding service interface.
In some possible embodiments, the at least one processor configured to determine, based on the hardware parameter, that an application corresponding to the service unit identification has a binding relationship, the determining module is configured to:
acquiring a preset binding relationship set by the binding service unit, wherein the binding relationship set comprises service unit identifications meeting preset conditions and at least one processor with a binding relationship of application programs corresponding to the service unit identifications;
screening out a binding relationship associated with the application program corresponding to the service unit identifier from the binding relationship set according to the hardware parameter, and determining the at least one processor corresponding to the application program according to the binding relationship.
In some possible embodiments, the notifying, by the tiering service unit, the Linux kernel layer of the tiering relationship, the notifying module is configured to:
calling a third core binding service interface contained in the core binding service unit, and sending the core binding relationship to a fourth core binding service interface of the hardware abstraction layer;
and calling a fourth core binding service interface contained in the hardware abstraction layer, and sending the core binding relationship to the Linux kernel layer.
In some possible embodiments, before sending the core binding request to a core binding service unit in response to the core binding request triggered by the application layer or the system framework layer, the sending module is further configured to:
calling an init daemon by the Linux kernel layer to acquire a configuration file corresponding to the binding service;
and analyzing the configuration file, and loading and initializing the binding service unit.
In some possible embodiments, the configuration file is parsed, and the binding service unit is loaded and initialized, and the sending module is configured to:
analyzing the configuration file, and executing a CPU parameter initializing process through the hardware abstraction layer to obtain the hardware parameters of the Linux kernel layer;
and calling the hardware abstraction layer to perform service type registration to a HwServiceManager, and registering the service type communicated with the binding service unit as a hwbinder service type.
In a third aspect, an embodiment of the present application provides an electronic device, including:
a memory for storing a computer program executable by the controller;
a controller is connected to the memory and is configured to perform the method of any of the first aspects described above.
In a fourth aspect, embodiments of the present application provide a computer-readable storage medium, where instructions, when executed by a processor, enable the processor to perform the method of any one of the above first aspects.
To sum up, in the embodiment of the application, in response to a core binding request triggered by an application layer or a system framework layer, an intelligent terminal may send the core binding request to a core binding service unit, and the core binding service unit determines, according to the obtained hardware parameter of a Linux kernel layer, at least one processor having a core binding relationship with an application corresponding to a service unit identifier, and then the core binding service unit notifies the Linux kernel layer of the core binding relationship, and in response to a hardware calling requirement of the application, the Linux kernel layer may call the at least one processor according to the core binding relationship; in this way, the binding service unit determines the binding relationship which more meets the requirement of the binding request according to the acquired hardware parameters of the Linux kernel layer, and informs the Linux kernel layer of the binding relationship, so that the freedom and convenience of development in an application program layer and a system framework layer are improved; because the system software architecture adopts a layered architecture, the migration adaptation can be rapidly carried out on different hardware platforms, and the complexity of the transplantation is greatly reduced; meanwhile, in the embodiment of the application, the core binding service unit can specifically bind the application program according to the characteristics of different performance scenes, so that the operating efficiency of the application program is met, and the response speed of the intelligent terminal is increased.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the embodiments of the present application will be briefly described below, and it is obvious that the drawings described below are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.
Fig. 1 is a schematic diagram of a system software architecture of an intelligent terminal according to an embodiment of the present application;
FIG. 2 is a schematic diagram illustrating an initialization process of a system software architecture according to an embodiment of the present application;
FIG. 3 is a diagram illustrating initialization of a system software architecture according to an embodiment of the present application;
FIG. 4 is a diagram illustrating initialization of a system software architecture according to an embodiment of the present application;
FIG. 5 is a flow chart illustrating binding of a processor according to an embodiment of the present application;
FIG. 6 is a schematic diagram illustrating a process for obtaining hardware parameters of a Linux kernel layer according to an embodiment of the present application;
fig. 7 is a schematic view of an application scenario for acquiring hardware parameters of a Linux kernel layer in an embodiment of the present application;
fig. 8 is a schematic diagram of an application scenario for acquiring hardware parameters of a Linux kernel layer in an embodiment of the present application;
FIG. 9 is a schematic flow chart illustrating a process of determining a binding relationship in an embodiment of the present application;
FIG. 10 is a flowchart illustrating an embodiment of a process for binding processors;
FIG. 11 is a diagram illustrating inter-binding service interface invocation in an embodiment of the present application;
FIG. 12 is a schematic view of one embodiment of an example of the present application;
FIG. 13 is a block diagram of a logical architecture of a binding apparatus of a processor according to an embodiment of the present application;
fig. 14 is a schematic physical architecture diagram of an electronic device according to an embodiment of the present application.
Detailed Description
In order to make the technical solutions of the present application better understood by those of ordinary skill in the art, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings.
It is noted that the terms first, second and the like in the description and in the claims of the present application are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the application described herein are capable of operation in sequences other than those illustrated or described herein. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present application. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present application, as detailed in the appended claims.
In order to solve the problem that a CPU pre-allocated to a bottom kernel in the prior art cannot meet the running efficiency required by a process, in the embodiment of the application, a core binding request triggered by an application program layer or a system framework layer can be responded, the core binding request can be sent to a core binding service unit, the core binding service unit determines at least one processor having a core binding relationship with an application program corresponding to a service unit identifier according to the acquired hardware parameter of the Linux kernel layer, and then the Linux kernel layer is informed of the core binding relationship by the core binding service unit.
In the embodiment of the present application, the intelligent terminal may be an intelligent mobile terminal, a tablet Computer, a notebook Computer, an intelligent handheld device, a Personal Computer (Personal Computer, PC), a Computer, an intelligent screen, various wearable devices, a Personal Digital Assistant (PDA), and the like. Nor is it limited in this application.
The preferred embodiments of the present application will be described in detail below with reference to the accompanying drawings, it being understood that the preferred embodiments described herein are merely for purposes of illustration and explanation and are not intended to limit the present application, and that the features of the embodiments and examples of the present application may be combined with one another without conflict.
Fig. 1 shows a system software architecture diagram of an intelligent terminal. Referring to fig. 1, in the embodiment of the present Application, an android system software architecture 100 of an intelligent terminal includes, from top to bottom, an Application (APP) layer 101, a system Framework (Framework) layer 102, a Hardware Abstraction (HAL) layer 103, and a Linux Kernel (Kernel) layer 104.
In the embodiment of the application, a development code for the core binding service unit 105 is embedded in the native software architecture of the android system, a core binding service interface is obtained by packaging a bottom interface included in the Linux kernel layer 104, and the core binding service interface is called to realize deep adaptation of a core binding request triggered by the application program layer 101 or the system framework layer 102, so that a core scheduling strategy which is relatively smooth and more appropriate is matched according to different performance scenes.
In the embodiment of the application, referring to fig. 2, when the android system is initialized, the following steps are executed to load and initialize the core binding service unit:
step 200: and calling an init daemon by the Linux kernel layer to acquire a configuration file corresponding to the binding service.
In the embodiment of the application, in the starting process of the android system of the intelligent terminal, the android system is started under the guidance of Boot Loader, specifically, when the intelligent terminal is in a Power-off state, the intelligent terminal is started by pressing a Power key for a long time by a user, a chip is guided to start to execute from a preset code solidified in a Read-Only Memory (ROM), a guide program is loaded to a Random-access Memory (RAM), and hardware parameter initialization and the like are performed.
And then, starting the Linux kernel, acquiring an init.rc file from the system file, calling an init daemon, and acquiring a configuration file corresponding to the binding service.
Step 210: and analyzing the configuration file, loading and initializing the binding service unit.
In the embodiment of the present application, when step 210 is executed, first, the configuration file is analyzed, and the process of initializing the CPU parameters is executed through the hardware abstraction layer to obtain the hardware parameters of the Linux kernel layer; and then, calling the hardware abstraction layer to register the service type to the HwServiceManager, and registering the service type communicated with the binding service unit as the hwbinder service type.
Optionally, referring to fig. 1, when step 210 is executed, the Linux kernel layer 104 calls an init daemon to analyze the configuration file, develops a section of code on the hardware abstraction layer 103 in the native software architecture of the android system, configures the fourth core binding service interface 109, and implements a function of calling the fourth core binding service interface 109 to obtain a hardware parameter of the Linux kernel layer 104; then, the binding Service unit 105 is loaded and initialized, where the binding Service unit (Turbo Service)105 is configured to obtain a hardware parameter of the Linux kernel layer 104 according to a binding request triggered by the application layer 101 or the system framework layer 102, determine, according to the hardware parameter, at least one processor having a binding relationship with an application corresponding to a Service unit identifier included in the binding request, and notify the Linux kernel layer 104 of the binding relationship, so that when a hardware calling requirement of the application is responded, the Linux kernel layer 104 calls the at least one processor according to the binding relationship, thereby implementing corresponding deep adaptation.
In the embodiment of the application, when the core binding service unit is loaded and initialized, the third core binding service interface 108 is configured, then, a corresponding section of code is developed on the system framework layer 102, the second core binding service interface 107 is configured, and the function of sending a core binding request triggered by the system framework layer 102 to the core binding service unit 105 by calling the second core binding service interface 107 is realized, so that the performance optimization and the deep adaptation in the native software architecture of the android system are realized by triggering the core binding service interface.
Correspondingly, a section of code is developed on the application program layer, the first binding service interface 106 is configured, and the function of sending the binding request triggered by the application program layer 101 to the binding service unit 105 by calling the first binding service interface 106 is realized, so that the performance optimization and the deep adaptation in the native software architecture of the android system are realized by triggering the binding service interface.
For example, referring to FIG. 3, the hardware abstraction layer (Turbo HAL) initialization is used as an example.
In the embodiment of the application, the Turbo HAL process is an independent HAL layer process, and provides services to an upper layer according to a hidl framework in a native software architecture of an android system.
Optionally, the Turbo HAL process is called by parsing a corresponding configuration file (e.g., an rc file) in the init boot process, and is a native daemon process.
Specifically, the Turbo HAL process executes the process of initializing the CPU parameters by analyzing the configuration file, and obtains the hardware parameters of the Linux kernel layer.
Optionally, in this embodiment of the application, an initcpupias method of CpuHalManager may be adopted to execute a CPU parameter initialization process to obtain hardware parameters of a Linux kernel layer, where the CPU parameter initialization process includes kernel number compatibility, kernel size and frequency determination, and the like.
Then, calling the Turbo HAL process to register the service type to the HwServiceManager, and registering the service type communicated with the binding service unit as the hwbinder service type.
Optionally, in this embodiment of the present application, the registration service type may be implemented by using a register asservice method, and registers the hwservermanager as a real-name hwbinder service, so that a Hardware Abstraction (HAL) layer process may have a capability of providing a core binding service across processes.
For another example, referring to fig. 4, initialization of a binding Service unit (Turbo Service) is taken as an example.
In the embodiment of the application, the Turbo Service process is an independent process of a binding Service unit, has a system uid, is a core of a java layer binding Service, and is used for providing a binding Service for a system framework layer process (such as a system _ server process) or an application program layer (Turbo HAL) process.
In the specific implementation, in the startOtherService method of the systemServer startup process, a binding Service unit (Turbo Service) is started by a Service startup auxiliary class SystemServiceManager in a native system architecture of an android system, so as to obtain a Turbo Service binder agent.
Optionally, in this embodiment of the present application, the above-mentioned starting manner may adopt a bindeService, that is, an anonymous binder service. Since the binding Service capability of the binding Service unit (Turbo Service) is supported by the hardware abstraction layer (Turbo HAL) process, the binding Service agent of the hardware abstraction layer (Turbo HAL) can be acquired through hidl by the above-mentioned start initialization.
In the embodiment of the application, after the core binding service unit obtains the core binding service agent of the hardware abstraction layer, the application program layer can realize cross-process communication with the core binding service unit by calling the corresponding first core binding service interface.
In the embodiment of the application, because the application layer is embedded with the Turbo lib jar (SDK) packet, the application layer can perform cross-process communication with the binding Service unit (Turbo Service) through the SDK jar packet by using aidl.
In the embodiment of the application, the obtained Turbo Service binder agent is maintained and used through the Turbo Service provider tool class, so that when the system framework calls the second core binding interface, the obtained Turbo Service binder agent can be packaged through the Turbo Service provider tool class.
Referring to fig. 5, in the embodiment of the present application, a specific process of binding the processor by the intelligent terminal is as follows:
step 500: and responding to a core binding request triggered by an application program layer or a system framework layer, and sending the core binding request to a core binding service unit, wherein the core binding request contains a service unit identifier needing core binding operation.
In the embodiment of the present application, the layer sent according to the binding request includes, but is not limited to, the following two cases:
in the first case, if the running state of the application program corresponding to the service unit identifier meets a first preset condition, triggering the core binding request through an application program layer; the first preset condition includes that the required resource amount of the application program corresponding to the service unit identifier exceeds a first threshold, and/or the total number of processes contained in the application program corresponding to the service unit identifier reaches a second threshold.
Then, in the embodiment of the application, after receiving a core binding request triggered by an application layer, the intelligent terminal responds to the core binding request, calls a first core binding service interface included in the application layer, and sends the core binding request to a core binding service unit, so that the core binding service unit calls a third core binding interface to obtain a hardware parameter of a Linux kernel layer. And determining the corresponding at least one processor according to the acquired hardware parameters.
For example, assume that the service unit identifies that the corresponding application contains up to 6 total processes and that the first threshold is 7.
Then, the intelligent terminal determines that the running state of the application program corresponding to the service unit identifier meets a first preset condition, the application program layer triggers a core binding request, and then, the intelligent terminal responds to the core binding request triggered by the application program layer, calls a first core binding service interface contained in the application program layer, and sends the core binding request to the core binding service unit.
In the second case, in the embodiment of the application, if the system framework layer monitors a process meeting a second preset condition, a core binding request is triggered through the system framework layer; the second preset condition includes that the running speed corresponding to the existing process and/or the existing thread is lower than a third threshold, and/or the Activity cold start needs to be established.
Then, in the embodiment of the application, after receiving a core binding request triggered by a system framework layer, the intelligent terminal responds to the core binding request, calls a second core binding service interface included in the system framework layer, and sends the core binding request to the core binding service unit, so that the core binding service unit calls a third core binding interface to obtain the hardware parameters of the Linux kernel layer. And determining the corresponding at least one processor according to the acquired hardware parameters.
For example, assume that a need to create a new process for an Activity cold start is monitored by the system framework layer.
Then, the intelligent terminal determines that the system framework layer monitors a process meeting a second preset condition, the system framework layer triggers a core binding request, and then the intelligent terminal responds to the core binding request triggered by the system framework layer, calls a second core binding service interface contained in the system framework layer and sends the core binding request to a core binding service unit.
Step 510: and acquiring the hardware parameters of the Linux kernel layer by the binding service unit.
In the embodiment of the present application, referring to fig. 6, when step 510 is executed, the following steps may be executed to obtain the hardware parameter of the Linux kernel layer:
step 5101: and calling a third binding service interface contained in the binding service unit, and sending an acquisition request to the hardware abstraction layer, wherein the acquisition request is used for acquiring the hardware parameters of the Linux kernel layer.
In the embodiment of the application, an acquisition request for acquiring the hardware parameters of the Linux kernel layer is sent to the hardware abstraction layer (i.e., Turbo HAL) by calling the second binding Service interface included in the binding Service unit (i.e., Turbo Service).
Step 5102: and calling a fourth core binding service interface contained in the hardware abstraction layer according to the acquisition request, acquiring the hardware parameters of the Linux kernel layer, calling the fourth core binding service interface and sending the fourth core binding service interface to the third core binding service interface.
In this embodiment of the application, when step 5102 is executed, according to each preset core binding service interface, a fourth core binding service interface included in the hardware abstraction layer is called to obtain a hardware parameter of the Linux kernel layer, and then, the fourth core binding service interface included in the hardware abstraction layer is called to send the obtained hardware parameter of the Linux kernel layer to the third core binding service interface.
Step 5103: and the binding service unit receives the hardware parameters through the third binding service interface.
In this embodiment of the present application, the core binding service unit receives the hardware parameter of the Linux kernel layer through the included third core binding service interface, so as to execute step 520, and determine at least one processor having a core binding relationship with the application program corresponding to the service unit identifier included in the core binding request.
For example, referring to fig. 7, an application layer trigger core binding request is taken as an example.
Assume that the service unit identifies that the amount of required resources of the corresponding application a exceeds a first threshold.
The application program layer triggers a core binding request, and the intelligent terminal responds to the core binding request triggered by the application program layer, calls a first core binding service interface contained in the application program layer and sends the core binding request to the core binding service unit.
Then, after receiving the core binding request, the core binding service unit calls a third core binding service interface included in the core binding service unit, and sends an acquisition request for acquiring the hardware parameters of the Linux kernel layer to the hardware abstraction layer.
Correspondingly, the hardware abstraction layer calls the corresponding fourth core binding service interface according to the obtaining request, obtains the hardware parameter of the Linux kernel layer, calls the fourth core binding service interface and sends the fourth core binding service interface to the third core binding service interface, and therefore the core binding service unit receives the hardware parameter through the third core binding service interface.
For another example, referring to fig. 8, the system framework layer triggers a core binding request.
Suppose the system framework layer detects that a corresponding process needs to be created for an Activity cold start.
The system framework layer triggers a core binding request, the intelligent terminal responds to the core binding request triggered by the system framework layer, calls a second core binding service interface contained in the system framework layer, and sends the core binding request to the core binding service unit.
Then, after receiving the core binding request, the core binding service unit calls a third core binding service interface included in the core binding service unit, and sends an acquisition request for acquiring the hardware parameters of the Linux kernel layer to the hardware abstraction layer.
Correspondingly, the hardware abstraction layer calls the corresponding fourth core binding service interface according to the obtaining request, obtains the hardware parameter of the Linux kernel layer, calls the fourth core binding service interface and sends the fourth core binding service interface to the third core binding service interface, and therefore the core binding service unit receives the hardware parameter through the third core binding service interface.
Step 520: and determining at least one processor having a binding relationship with the application program corresponding to the service unit identification according to the hardware parameter.
In the embodiment of the present application, referring to fig. 9, when step 520 is executed, at least one processor that determines that the application program corresponding to the service unit identifier has a binding relationship may be determined by executing steps 5201 to 5202:
step 5201: and the binding service unit acquires a preset binding relationship set, wherein the binding relationship set comprises service unit identifications meeting preset conditions and at least one processor with a binding relationship of corresponding application programs.
In the embodiment of the application, when a software architecture of the android system is initialized, a preset binding relationship set can be stored in a local memory of a binding service unit; then, when step 5201 is executed, the predetermined binding relationship set is obtained by the binding service unit.
Optionally, when the software architecture of the android system is initialized, a preset binding relationship set may also be stored in the database associated with the binding service unit.
Step 5202: and screening out the binding relationship associated with the application program corresponding to the service unit identification from the binding relationship set according to the hardware parameters, and determining at least one processor corresponding to the application program according to the binding relationship.
In the embodiment of the present application, after step 510 is executed, the core binding service unit obtains the hardware parameter of the corresponding Linux kernel layer, and then, when step 5202 is executed, according to the hardware parameter, screens out a core binding relationship associated with the application program corresponding to the service unit identifier included in the core binding request from the core binding relationship set obtained after step 5201 is executed, and determines at least one processor corresponding to the application program according to the core binding relationship.
Step 530: and the binding service unit informs the Linux kernel layer of the binding relationship.
In the embodiment of the present application, referring to fig. 10, when step 530 is executed, the obtained binding relationship may be notified to the Linux kernel layer by executing the following steps:
step 5301: and calling a third binding service interface contained in the binding service unit, and sending the binding relationship to a fourth binding service interface of the hardware abstraction layer.
In this embodiment, when step 520 is executed, at least one processor having a binding relationship with an application corresponding to the service unit identifier is determined, and then, when step 5301 is executed, the third binding service interface included in the binding service unit is called, and the binding relationship is sent to the fourth binding service interface included in the hardware abstraction layer.
Step 5302: and calling a fourth core binding service interface contained in the hardware abstraction layer, and sending the core binding relationship to the Linux kernel layer.
In this embodiment of the application, when step 5302 is executed, the fourth binding service interface included in the hardware abstraction layer is called, and the binding relationship is sent to the Linux kernel layer, so that when the hardware call requirement of the application program corresponding to the service unit identifier included in the binding request is responded, the Linux kernel layer calls at least one processor corresponding to the binding relationship according to the binding relationship.
Step 540: and responding to the hardware calling requirement of the application program, and calling at least one processor by the Linux kernel layer according to the binding relation.
In the embodiment of the application, according to the binding relationship, when the hardware calling requirement of the application program corresponding to the service unit identifier contained in the binding request is responded, the determined at least one processor is smoothly bound with the application program, so that the purpose that a more matched processor is provided for the application program according to the hardware calling requirement is achieved, more CPU operation resource supports are provided, the operation efficiency of the application program is met, the response speed of the intelligent terminal is improved, and meanwhile, the bad power consumption of the intelligent terminal is reduced.
In the embodiment of the present application, fig. 11 illustrates a schematic diagram of inter-binding service interface calls.
Referring to fig. 11, in an android system software architecture of an intelligent terminal, at least four independent processes are involved, which are an APP process corresponding to an application program layer, a Turbo frame process corresponding to a system frame layer, a Turbo Server process corresponding to a binding service unit, and a Turbo HAL process corresponding to a hardware abstraction layer in sequence, where a communication mechanism between the APP process or the Turbo frame process and the Turbo Server process is registered as a binder service type; the communication mechanism between the Turbo Server process and the Turbo HAL process is registered as a hwbinder service type; the communication mechanism between the Turbo HAL process and the Linux kernel is registered as a syscall service type.
For example, referring to fig. 12, the system framework layer triggers the core binding request.
Suppose that a need to create a new APP process for Activity cold start is monitored by the system framework layer.
In the embodiment of the application, the Activity Cold Start process of the intelligent terminal is embedded with the Activity monitor, and when the Activity monitor (running in a system framework layer) monitors that a new APP process needs to be created for the Activity Cold Start, the intelligent terminal responds to a core binding request triggered by the system framework layer and calls the second core binding service interface to send the core binding request to the core binding service unit.
And then, the core binding service unit acquires hardware parameters of the Linux according to the kernel layer according to the third core binding service interface, and determines at least one processor with a core binding relationship with an application program corresponding to the service unit identifier contained in the core binding request according to the hardware parameters.
And finally, the core binding service unit sends the core binding relationship to a Linux kernel layer, and in response to the hardware calling requirement of the application program, the Linux kernel layer calls at least one processor according to the core binding relationship, so that the accelerated Activity cold start is optimized, and thus, the time-consuming operations such as APP resource loading, User Interface (UI) drawing and the like can be completed to the greatest extent by using the resources of the at least one processor, so that the Activity start is accelerated.
After introducing the binding method for the processor provided in the embodiment of the present application, according to the same inventive concept, the following describes in detail the binding apparatus for the processor provided in the embodiment of the present application:
referring to fig. 13, the binding apparatus of the processor includes a sending module 1310, a determining module 1320, a notifying module 1330, and a calling module 1340, specifically:
a sending module 1310, configured to send a core binding request to a core binding service unit in response to the core binding request triggered by the application layer or the system framework layer, where the core binding request includes a service unit identifier that needs to perform a core binding operation;
a determining module 1320, configured to obtain, by the core binding service unit, a hardware parameter of the Linux kernel layer, and determine, according to the hardware parameter, at least one processor having a core binding relationship with an application program corresponding to the service unit identifier;
a notification module 1330, configured to notify, by the tiering service unit, the Linux kernel layer of the tiering relationship;
the calling module 1340 is configured to respond to a hardware calling requirement of the application program, and call, by the Linux kernel layer, the at least one processor according to the core binding relationship.
In some possible embodiments, the application layer triggers the binding request, and the sending module 1310 is configured to:
if the running state of the application program corresponding to the service unit identifier meets a first preset condition, triggering the core binding request through the application program layer;
the system framework layer triggers the binding request, and the sending module 1310 is configured to:
and if the system framework layer monitors a process meeting a second preset condition, triggering the core binding request through the system framework layer.
In some possible embodiments, the first preset condition includes that the required resource amount of the application program corresponding to the service unit identifier exceeds a first threshold, and/or the total number of processes included in the application program corresponding to the service unit identifier reaches a second threshold;
the second preset condition comprises that the running speed corresponding to the existing process and/or the existing thread is lower than a third threshold value, and/or the Activity cold start needs to be established.
In some possible embodiments, the sending module 1310 is configured to send the binding request to a binding service unit:
calling a first core binding service interface contained in the application program layer or calling a second core binding service interface contained in the system framework layer, and sending the core binding request to the core binding service unit;
the binding service unit acquires the hardware parameters of the Linux kernel layer, and the determining module is used for:
calling a third core binding service interface contained in the core binding service unit, and sending an acquisition request to the hardware abstraction layer, wherein the acquisition request is used for acquiring the hardware parameters of the Linux kernel layer;
calling a fourth binding service interface contained in the hardware abstraction layer according to the acquisition request, acquiring the hardware parameter of the Linux kernel layer, and calling the fourth binding service interface to send the fourth binding service interface to the third binding service interface;
and the core binding service unit receives the hardware parameters through the third core binding service interface.
In some possible embodiments, the determining module 1320 is configured to determine, according to the hardware parameter, that the application program corresponding to the service unit identifier has a binding relationship, and to:
acquiring a preset binding relationship set by the binding service unit, wherein the binding relationship set comprises service unit identifications meeting preset conditions and at least one processor with a binding relationship of application programs corresponding to the service unit identifications;
screening out a binding relationship associated with the application program corresponding to the service unit identifier from the binding relationship set according to the hardware parameter, and determining the at least one processor corresponding to the application program according to the binding relationship.
In some possible embodiments, the notifying module 1330 is configured to notify, by the tiering service unit, the Linux kernel layer of the tiering relationship, and to:
calling a third core binding service interface contained in the core binding service unit, and sending the core binding relationship to a fourth core binding service interface of the hardware abstraction layer;
and calling a fourth core binding service interface contained in the hardware abstraction layer, and sending the core binding relationship to the Linux kernel layer.
In some possible embodiments, before sending the core binding request to a core binding service unit in response to the core binding request triggered by the application layer or the system framework layer, the sending module 1310 is further configured to:
calling an init daemon by the Linux kernel layer to acquire a configuration file corresponding to the binding service;
and analyzing the configuration file, and loading and initializing the binding service unit.
In some possible embodiments, the configuration file is parsed, and the binding service unit is loaded and initialized, and the sending module 1310 is configured to:
analyzing the configuration file, and executing a CPU parameter initializing process through the hardware abstraction layer to obtain the hardware parameters of the Linux kernel layer;
and calling the hardware abstraction layer to perform service type registration to a HwServiceManager, and registering the service type of the binding service unit as a hwbinder service type.
After introducing the binding apparatus of the processor provided in the embodiment of the present application, according to the same inventive concept, the following describes in detail the electronic device provided in the embodiment of the present application:
referring to fig. 14, the electronic device includes a memory 1401 and a controller 1402, specifically:
a memory 1401 for storing a computer program executable by the controller 1402.
The controller 1402 is connected to the memory 1401, and is configured to perform:
responding to a core binding request triggered by the application program layer or the system framework layer, and sending the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation;
acquiring hardware parameters of the Linux kernel layer by the core binding service unit, and determining at least one processor having a core binding relationship with an application program corresponding to the service unit identifier according to the hardware parameters;
notifying, by the tieing service unit, the Linux kernel layer of the tieing relationship;
and responding to the hardware calling requirement of the application program, and calling the at least one processor by the Linux kernel layer according to the binding relationship.
Having described the electronic device provided by the embodiments of the present application, according to the same inventive concept, the embodiments of the present application further provide a computer-readable storage medium, wherein when the instructions in the storage medium are executed by a processor, the processor is enabled to execute the following method:
responding to a core binding request triggered by the application program layer or the system framework layer, and sending the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation;
acquiring hardware parameters of the Linux kernel layer by the core binding service unit, and determining at least one processor having a core binding relationship with an application program corresponding to the service unit identifier according to the hardware parameters;
notifying, by the tieing service unit, the Linux kernel layer of the tieing relationship;
and responding to the hardware calling requirement of the application program, and calling the at least one processor by the Linux kernel layer according to the binding relationship.
To sum up, in the embodiment of the present application, the system software architecture of the intelligent terminal includes an application layer, a system framework layer, a hardware abstraction layer, and a Linux kernel layer from top to bottom, and then, in response to a core binding request triggered by the application layer or the system framework layer, the core binding request is sent to a core binding service unit, where the core binding request includes a service unit identifier that needs to perform core binding operation; acquiring hardware parameters of a Linux kernel layer by a binding service unit, and determining at least one processor with binding relation with an application program corresponding to a service unit identifier according to the hardware parameters; notifying the Linux kernel layer of the binding relationship by a binding service unit; responding to the hardware calling requirement of the application program, and calling at least one processor by the Linux kernel layer according to the binding relation; in this way, a relatively independent binding service unit is added in a system software architecture of the intelligent terminal, a binding relationship which is more in line with the requirement of a binding request is determined by the binding service unit according to the acquired hardware parameters of the Linux kernel layer, and the Linux kernel layer is informed of the binding relationship by the binding service unit, so that the degree of freedom and convenience in development of an application program layer and a system framework layer are improved; because the system software architecture adopts a layered architecture, the migration adaptation can be rapidly carried out on different hardware platforms, and the complexity of the transplantation is greatly reduced; meanwhile, in the embodiment of the application, the core binding service unit can specifically bind the application program according to the characteristics of different performance scenes, so that the operating efficiency of the application program is met, and the response speed of the intelligent terminal is increased.
As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present application without departing from the spirit and scope of the application. Thus, if such modifications and variations of the present application fall within the scope of the claims of the present application and their equivalents, the present application is intended to include such modifications and variations as well.
Claims (10)
1. A binding method of a processor is applied to an intelligent terminal, a system software architecture of the intelligent terminal comprises an application program layer, a system framework layer, a hardware abstraction layer and a Linux kernel layer from top to bottom, and the method comprises the following steps:
responding to a core binding request triggered by the application program layer or the system framework layer, and sending the core binding request to a core binding service unit, wherein the core binding request comprises a service unit identifier needing core binding operation;
acquiring hardware parameters of the Linux kernel layer by the core binding service unit, and determining at least one processor having a core binding relationship with an application program corresponding to the service unit identifier according to the hardware parameters;
notifying, by the tieing service unit, the Linux kernel layer of the tieing relationship;
and responding to the hardware calling requirement of the application program, and calling the at least one processor by the Linux kernel layer according to the binding relationship.
2. The method of claim 1, wherein the application layer triggering the binding request comprises:
if the running state of the application program corresponding to the service unit identifier meets a first preset condition, triggering the core binding request through the application program layer;
the system framework layer triggers the core binding request, and the method comprises the following steps:
and if the system framework layer monitors a process meeting a second preset condition, triggering the core binding request through the system framework layer.
3. The method according to claim 2, wherein the first preset condition includes that the required resource amount of the application program corresponding to the service unit identifier exceeds a first threshold, and/or that the total number of processes included in the application program corresponding to the service unit identifier reaches a second threshold;
the second preset condition comprises that the running speed corresponding to the existing process and/or the existing thread is lower than a third threshold value, and/or the Activity cold start needs to be established.
4. The method of claim 1, wherein said sending the binding request to a binding service unit comprises:
calling a first core binding service interface contained in the application program layer or calling a second core binding service interface contained in the system framework layer, and sending the core binding request to the core binding service unit;
acquiring the hardware parameters of the Linux kernel layer by the binding service unit, wherein the hardware parameters comprise:
calling a third core binding service interface contained in the core binding service unit, and sending an acquisition request to the hardware abstraction layer, wherein the acquisition request is used for acquiring the hardware parameters of the Linux kernel layer;
calling a fourth binding service interface contained in the hardware abstraction layer according to the acquisition request, acquiring the hardware parameter of the Linux kernel layer, and calling the fourth binding service interface to send the fourth binding service interface to the third binding service interface;
and the core binding service unit receives the hardware parameters through the third core binding service interface.
5. The method of claim 1, wherein said determining from the hardware parameters that the application corresponding to the service unit identification has a binding relationship comprises:
acquiring a preset binding relationship set by the binding service unit, wherein the binding relationship set comprises service unit identifications meeting preset conditions and at least one processor with a binding relationship of application programs corresponding to the service unit identifications;
screening out a binding relationship associated with the application program corresponding to the service unit identifier from the binding relationship set according to the hardware parameter, and determining the at least one processor corresponding to the application program according to the binding relationship.
6. The method of any one of claims 1-5, wherein said notifying, by said tieing service, said Linux kernel layer of said tieing relationship comprises:
calling a third core binding service interface contained in the core binding service unit, and sending the core binding relationship to a fourth core binding service interface of the hardware abstraction layer;
and calling a fourth core binding service interface contained in the hardware abstraction layer, and sending the core binding relationship to the Linux kernel layer.
7. The method of claim 1, prior to sending a binding request to a binding service unit in response to the application layer or system framework layer triggered binding request, further comprising:
calling an init daemon by the Linux kernel layer to acquire a configuration file corresponding to the binding service;
and analyzing the configuration file, and loading and initializing the binding service unit.
8. The method of claim 7, wherein parsing the configuration file, loading and initializing the binding service unit comprises:
analyzing the configuration file, and executing a CPU parameter initializing process through the hardware abstraction layer to obtain the hardware parameters of the Linux kernel layer;
and calling the hardware abstraction layer to perform service type registration to a HwServiceManager, and registering the service type communicated with the binding service unit as a hwbinder service type.
9. An electronic device, comprising:
a memory for storing a computer program executable by the controller;
a controller is coupled to the memory and configured to perform the method of any of claims 1-8.
10. A computer-readable storage medium, wherein instructions in the storage medium, when executed by a processor, enable the processor to perform the method of any of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111002197.9A CN113760374B (en) | 2021-08-30 | 2021-08-30 | Binding method and device of processor and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111002197.9A CN113760374B (en) | 2021-08-30 | 2021-08-30 | Binding method and device of processor and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113760374A true CN113760374A (en) | 2021-12-07 |
| CN113760374B CN113760374B (en) | 2023-04-21 |
Family
ID=78791719
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111002197.9A Active CN113760374B (en) | 2021-08-30 | 2021-08-30 | Binding method and device of processor and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113760374B (en) |
Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20080134325A1 (en) * | 2006-12-05 | 2008-06-05 | Samsung Electronics Co., Ltd. | Application program launching method and system for improving security of embedded linux kernel |
| US20080184233A1 (en) * | 2007-01-30 | 2008-07-31 | Norton Scott J | Abstracting a multithreaded processor core to a single threaded processor core |
| CN103176780A (en) * | 2011-12-22 | 2013-06-26 | 中国科学院声学研究所 | Binding system and method of multiple network interfaces |
| CN107977267A (en) * | 2016-10-25 | 2018-05-01 | 航天信息股份有限公司 | For improving the method and apparatus of one process network program performance |
| CN108804148A (en) * | 2018-05-31 | 2018-11-13 | 杭州宏杉科技股份有限公司 | A kind of method and device of binding relationship that establishing equipment and driving |
| CN110955499A (en) * | 2018-09-26 | 2020-04-03 | Oppo广东移动通信有限公司 | Processor core configuration method, device, terminal and storage medium |
| CN111625293A (en) * | 2020-05-15 | 2020-09-04 | 武汉蓝星科技股份有限公司 | Terminal dual system based on linux kernel and hardware access management method thereof |
| CN112416513A (en) * | 2020-11-18 | 2021-02-26 | 烽火通信科技股份有限公司 | Method and system for dynamically adjusting dominant frequency of virtual machine in cloud network |
| CN113110960A (en) * | 2021-04-15 | 2021-07-13 | 山东英信计算机技术有限公司 | Automatic tuning test method and system based on hard disk performance |
-
2021
- 2021-08-30 CN CN202111002197.9A patent/CN113760374B/en active Active
Patent Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20080134325A1 (en) * | 2006-12-05 | 2008-06-05 | Samsung Electronics Co., Ltd. | Application program launching method and system for improving security of embedded linux kernel |
| US20080184233A1 (en) * | 2007-01-30 | 2008-07-31 | Norton Scott J | Abstracting a multithreaded processor core to a single threaded processor core |
| CN103176780A (en) * | 2011-12-22 | 2013-06-26 | 中国科学院声学研究所 | Binding system and method of multiple network interfaces |
| CN107977267A (en) * | 2016-10-25 | 2018-05-01 | 航天信息股份有限公司 | For improving the method and apparatus of one process network program performance |
| CN108804148A (en) * | 2018-05-31 | 2018-11-13 | 杭州宏杉科技股份有限公司 | A kind of method and device of binding relationship that establishing equipment and driving |
| CN110955499A (en) * | 2018-09-26 | 2020-04-03 | Oppo广东移动通信有限公司 | Processor core configuration method, device, terminal and storage medium |
| CN111625293A (en) * | 2020-05-15 | 2020-09-04 | 武汉蓝星科技股份有限公司 | Terminal dual system based on linux kernel and hardware access management method thereof |
| CN112416513A (en) * | 2020-11-18 | 2021-02-26 | 烽火通信科技股份有限公司 | Method and system for dynamically adjusting dominant frequency of virtual machine in cloud network |
| CN113110960A (en) * | 2021-04-15 | 2021-07-13 | 山东英信计算机技术有限公司 | Automatic tuning test method and system based on hard disk performance |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113760374B (en) | 2023-04-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP7197612B2 (en) | Execution of auxiliary functions on on-demand network code execution systems | |
| US10817331B2 (en) | Execution of auxiliary functions in an on-demand network code execution system | |
| US11875173B2 (en) | Execution of auxiliary functions in an on-demand network code execution system | |
| US20200218582A1 (en) | System and method for processing task resources | |
| US10949237B2 (en) | Operating system customization in an on-demand network code execution system | |
| US10768960B2 (en) | Method for affinity binding of interrupt of virtual network interface card, and computer device | |
| US20210389970A1 (en) | Vnf lifecycle management method and apparatus | |
| CN111949364A (en) | Deployment method of containerized VNF and related equipment | |
| CN110597531B (en) | Distributed module upgrading method and device and storage medium | |
| JP2005518015A (en) | Middleware service layer for platform systems for mobile terminals | |
| CN108228444B (en) | Test method and device | |
| CN111221618B (en) | Deployment method and device for containerized virtual network function | |
| CN108141378B (en) | Dormant VDU in VNFD | |
| CN108809683B (en) | Method and device for deploying cloud application system | |
| CN110597564A (en) | Installation package construction and service component loading method, device and terminal equipment | |
| CN114691321A (en) | Task scheduling method, device, equipment and storage medium | |
| CN112698930B (en) | Method, device, equipment and medium for obtaining server identification | |
| CN113885971A (en) | State management method and device based on self-adaptive platform system | |
| CN113821220A (en) | Installation method and device of linux operating system | |
| CN113760374B (en) | Binding method and device of processor and electronic equipment | |
| CN112306633B (en) | System and method for acquiring different virtualized resources | |
| CN114911538A (en) | Starting method of running system and computing equipment | |
| CN114564249A (en) | Recommendation scheduling engine, recommendation scheduling method, and computer-readable storage medium | |
| JP4063573B2 (en) | Device driver installation / execution method, installation / execution method, and program | |
| KR100981381B1 (en) | Device manegement agent and method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |