CN108197029B - Method and device for acquiring process information - Google Patents
Method and device for acquiring process information Download PDFInfo
- Publication number
- CN108197029B CN108197029B CN201810015256.8A CN201810015256A CN108197029B CN 108197029 B CN108197029 B CN 108197029B CN 201810015256 A CN201810015256 A CN 201810015256A CN 108197029 B CN108197029 B CN 108197029B
- Authority
- CN
- China
- Prior art keywords
- python
- event
- interpreter
- agent code
- python interpreter
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 151
- 230000008569 process Effects 0.000 title claims abstract description 125
- 238000004590 computer program Methods 0.000 claims description 10
- 239000003795 chemical substances by application Substances 0.000 description 26
- 238000010586 diagram Methods 0.000 description 13
- 230000006870 function Effects 0.000 description 12
- 238000004891 communication Methods 0.000 description 9
- 238000012545 processing Methods 0.000 description 6
- 238000012986 modification Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 5
- 230000001960 triggered effect Effects 0.000 description 5
- 238000005516 engineering process Methods 0.000 description 4
- 230000003287 optical effect Effects 0.000 description 4
- 238000011161 development Methods 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 230000000903 blocking effect Effects 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 230000006378 damage Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012552 review Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3636—Software debugging by tracing the execution of the program
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The embodiment of the invention discloses a method and equipment for acquiring process information, wherein the method comprises the following steps: the Python interpreter registers an event needing call back; in the process of executing the Python process by the Python interpreter, when the registered event occurs, the Python interpreter triggers an event callback and outputs the process information of the Python process. By using the technical scheme disclosed by the embodiment of the invention, the tracing capability of the Python interpreter can be enhanced without a third-party tool or modifying a service code.
Description
Technical Field
The invention relates to the technical field of cloud computing, in particular to a method and equipment for acquiring process information.
Background
With the rapid development of computer technology and network technology, cloud computing has become the most popular technology. The well-known cloud computing open source platform Openstack is developed based on Python language. Companies such as Google, Instagram, Dropbox, Youtube, Reddit, and quera are all using Python language to implement core business development.
The Python language is an object-oriented interpreted computer programming language. When a problem occurs in the running process of a program developed by using the Python language, the problem is debugged and located by looking up logs and source codes. For this purpose, some third party tools with tracking function, such as Yappi, Heapy, Pyflame, etc., have been developed for Python programs. Yappi is generally used for tracing Python multithreading; heapy is typically a variety of information used to show Python piles; pyflame uses the Linux ptrace system to collect trace information and generate a flame map corresponding to the Python process.
The existing third-party tool has single function and weak expandability. For example, Pyflame can only generate a flame map and is used for discovering a function hotspot; while Heapy and Yappi can only track Python memory.
Disclosure of Invention
The embodiment of the invention provides a method and equipment for acquiring process information, which enhances the tracking capability of a Python interpreter.
The embodiment of the invention provides a method for acquiring process information, which comprises the following steps:
the Python interpreter registers an event needing call back;
in the process of executing the Python process by the Python interpreter, when the registered event occurs, the Python interpreter triggers an event callback and outputs the process information of the Python process.
The embodiment of the invention also provides equipment for acquiring the process information, wherein a Python interpreter and a Python process run on the equipment, and the Python interpreter executes the Python process;
the Python interpreter is used for registering events needing call-back; and when the registered event occurs, triggering an event call-back and outputting the process information of the Python process.
Another apparatus for acquiring process information provided in an embodiment of the present invention includes:
the event registration module is used for registering events needing to be called back;
and the event call-back module is used for triggering an event call-back and outputting the process information of the Python process when a registered event occurs in the process of executing the Python process by the Python interpreter.
The embodiment of the present invention further provides a device for acquiring process information, which includes at least one processor and at least one memory, where the at least one memory is used for storing a computer program, and the at least one processor is used for calling a program code in the at least one memory to execute the method described in the embodiment of the present invention.
The embodiment of the invention also provides a computer storage medium, wherein the computer storage medium is stored with computer software instructions, and the computer software instructions enable a computer to execute the method recorded in the embodiment of the invention after running.
The technical scheme of the embodiment of the invention can enhance the tracking capability of the Python interpreter without the help of a third-party tool or modifying a service code.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive exercise.
FIG. 1 is a logic diagram of a Python interpreter according to an embodiment of the present invention;
fig. 2 is a schematic flow chart of a Python interpreter executing a Python program according to an embodiment of the present invention;
fig. 3 is a schematic flowchart of a method for acquiring process information according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of a device for acquiring process information according to an embodiment of the present invention;
fig. 5 is a logic structure diagram of a device for acquiring process information according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention clearer, the present invention will be described in further detail with reference to the accompanying drawings, and it is apparent that the described embodiments are only a part of the embodiments of the present invention, not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Fig. 1 is a logic diagram of a Python interpreter according to an embodiment of the present invention, which includes an event module 102, a load module 104, and an interface module 106. The Python interpreter realizes the functions of object management, module management, thread scheduling, memory management and the like; and further implements a loading mechanism and an event mechanism in the Python interpreter.
The existing Python interpreter has good introspection capability, but does not provide some finer-grained information such as thread switching, memory usage, etc. to the user. The event module 102, the loading module 104 and the interface module 106 in the Python interpreter in the embodiment of the invention enable the Python interpreter to have the dynamic tracking capability, and provide the process information of the Python process for the user, so that a third-party tracking tool is not required to be relied on.
The various modules of the Python interpreter are described in detail below.
By adding an event call-back hook to a set path of the Python interpreter, the event module 102 may register an event that may trigger an event call-back by using an event API (Application Programming Interface) provided by the Python interpreter. In the execution process of the Python program, whenever the Python interpreter executes to a corresponding set path, the callback of the registered event is executed, and the context information of the Python process at the moment is output. The user can track the process information of the Python process in the event call-back. The process information acquired by the event callback can be output in any manner at any time, such as being stored in a memory, or being output to a preset file, or being output to a message queue through a network, and the like. By way of example, callable events may include any combination of the following: memory application, memory release, function call, function exit, thread creation, thread blocking, thread running, thread destruction, exception creation, and the like.
An exemplary flow of executing a Python process corresponding to a Python program by using a Python interpreter according to an embodiment of the present invention is shown in fig. 2.
Firstly, a user registers an event needing call-back through an event API, then a Python process is executed according to the steps shown in fig. 2, and when the event registered by the user occurs, a corresponding event call-back is triggered, for example:
1) when a certain thread starts to be executed in the running process of the Python process, the call back of the thread creation event is correspondingly triggered;
2) when the Python process calls a certain function, the call back of a function calling event is correspondingly triggered;
3) the Python process creates an object, and correspondingly triggers the call-back of the memory application event;
4) and if the execution of the Python process throws an exception, a callback of an exception creating event is correspondingly triggered.
The load module 104 gives the Python interpreter the ability to track dynamically. The user can send a load request to notify the Python interpreter to execute the load operation at any time when the target Python process runs through another process, which is called a user process in the embodiment of the invention. The user process requests the Python interpreter to load the set trace logic and execute the trace logic. The code implementing these tracing logics is also called Agent code; the Agent code may collect process information for the Python process based on the event module 102 and the interface module 106 of an embodiment of the present invention.
The interface module 106 is used to provide the user with process information for the Python process. The process information of the Python process may be information representing the situation of the Python process directly obtained by the Python interpreter through an event callback, and may include context information of the Python process during running (for example, the memory size requested by a certain memory application, or the type of a newly created object, etc.). The process information of the Python process may also be statistical data (such as the number of thread switching, the number of garbage collection times, the collection duration, or the memory layout) obtained by processing the above information directly obtained according to the event callback.
Fig. 3 is a schematic flowchart of a method for acquiring process information according to an embodiment of the present invention.
302: the user process initiates a load request to the Python interpreter.
At any time when the Python interpreter interprets and executes the Python process (e.g., when the Python process starts executing), the user process may signal a load request to notify the Python interpreter of the load operation. After receiving the signal sent by the user process, the Python interpreter first determines whether the request is a load request, and if the request is a load request, the following step 304 is executed.
304: and after receiving the loading application, the Python interpreter establishes communication connection with the user process.
306: the user process sends the path of the Agent code to the Python interpreter.
After the communication connection between the user process and the Python interpreter executing the Python process is established, the Python interpreter loads the tracking logic set by the Agent code and executes the tracking logic on the Python process.
It should be noted that the user process may also carry control parameters while sending a path of the Agent code to the Python interpreter.
308: the Python interpreter loads the Agent code and registers events that need to be called back.
Loading and executing the tracing logic set by the Agent code on a Python interpreter; and registering the event needing to be called back by the Agent code through the event API.
If the Python interpreter receives a control parameter, the control parameter can be used as a command line option for executing Agent codes, such as sys. argv; the tracing logic for realizing Agent code setting according to the control parameter is executed differently.
310: the Python interpreter continues to execute the Python process and triggers an event callback.
The Python process continues to execute the business logic; when the Python process triggers an event callback in the execution process, the tracking logic set by the Agent code receives the process information of the Python process when the event callback is triggered.
After obtaining the process information of the Python process, the Python interpreter may output the process refinement system to the outside, for example, send the process information to a Linux system using a message queue or an information channel.
312: the user process initiates a request to the Python interpreter to unload the Agent code.
314: and after receiving the request of unloading the Agent code, the Python interpreter triggers an end callback.
After the Python interpreter triggers the end call-back, the event call-back will not be generated when the previously registered event occurs. While triggering the end callback, the Python interpreter may also clear the resources used by the event callback.
The example shown in fig. 3 is a request by a user process to signal a Python interpreter to unload Agent code, which may occur at any time while the Python process is running. Optionally, the Python interpreter may also set the time and conditions for unloading Agent codes according to the received control parameters; or waiting for the next time when a loading request initiated by the user process is received, emptying the last loaded Agent code by the Python interpreter.
The embodiment of the invention discloses a method for acquiring process information, which comprises the following steps:
the Python interpreter registers an event needing call back;
in the process of executing the Python process by the Python interpreter, when the registered event occurs, the Python interpreter triggers an event call-back and outputs the process information of the Python process.
Specifically, the Python interpreter may register an event that requires a callback by: a Python interpreter receives a path of an Agent code; the Python interpreter loads the Agent code and registers events that need callbacks.
Optionally, the Python interpreter may also receive a control parameter and control the execution of the trace logic set by the Agent code according to the control parameter.
Further, as shown in the embodiment of the present invention in fig. 3, the Python interpreter may unload Agent codes according to the Python's own needs, or received unloading requests, or under conditions set by control parameters.
The embodiment of the invention enhances the tracing capability of the Python interpreter without the help of a third party tool or modifying the service code. The embodiment of the invention can dynamically track a running Python process and acquire the process information under the condition of not stopping the Python process. According to the tracing technology provided by the embodiment of the invention, any tracing logic written in Python language can be dynamically loaded in an Agent loading mode, and the Python process can be conveniently traced. Further, the Python interpreter can also implement the tracing logic of the Agent code setting by controlling the parameters to execute differently.
The technical scheme of the embodiment of the invention can be used as the basis of the distributed Python service management, and the trace information is dynamically injected into the Python process under the conditions of not modifying the service code and not restarting the Python process, so that the management of the distributed service is realized.
The embodiment of the invention also discloses equipment for acquiring the process information, wherein a Python interpreter and a Python process run on the equipment, and the Python interpreter executes the Python process; the logic structure of the Python interpreter is shown in fig. 1, and is used to obtain the process information of the Python process by using the method disclosed above in the embodiment of the present invention, as implemented by the methods shown in fig. 2 and fig. 3.
The embodiment of the present invention also discloses an apparatus 400 for acquiring process information as shown in fig. 4, which includes at least one processor 401, at least one memory 403, and at least one communication interface 404.
The processor 401 may be a general purpose Central Processing Unit (CPU), microprocessor, application-specific integrated circuit (ASIC), or one or more integrated circuits configured to control the execution of programs in accordance with the teachings of the present application.
The communication interface 404 may be any device, such as a transceiver, for communicating with other devices or a communication network. The communication Network may be an ethernet, a Radio Access Network (RAN), a Wireless Local Area Network (WLAN), or the like.
The Memory 403 may be a Read-Only Memory (ROM), a static Memory device capable of storing static information and instructions, a Random Access Memory (RAM), or a dynamic Memory device capable of storing information and instructions, an Electrically Erasable Programmable Read-Only Memory (EEPROM), a Compact Disc Read-Only Memory (CD-ROM) or other optical disk storage, optical disk storage (including Compact Disc, laser Disc, optical Disc, digital versatile Disc, blu-ray Disc, etc.), a magnetic disk storage medium or other magnetic storage device, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer, but is not limited to these. The memory 403 may be separate or the memory 403 may be integrated with the processor 401.
The memory 403 may be used for storing application program codes for implementing the present application; processor 401 may be used to execute application program code stored in memory 403.
As one embodiment of a specific implementation, device 400 may include multiple processors, such as processor 401 and processor 408 in fig. 4. Each of these processors may be a single-core (single-CPU) processor or a multi-core (multi-CPU) processor. Each processor itself, such as processor 401, may include one or more CPUs, such as CPU0 and CPU 1.
The device 400 may be a general-purpose computer device, or a special-purpose computer device. In a specific implementation, the device 400 may be a desktop, a laptop, a web server, a Personal Digital Assistant (PDA), a mobile phone, a tablet, a wireless terminal device, a communication device, an embedded device, or the like. The embodiments of the present application do not limit the type of the device 400.
Fig. 5 is a logic structure diagram of a device for acquiring process information according to an embodiment of the present invention. The device includes an event registration module 502 and an event callback module 504.
An event registration module 502, configured to register an event that needs to be called back;
and the event callback module 504 is configured to trigger an event callback and output process information of the Python process when a registered event occurs in the process of executing the Python process by the Python interpreter.
The event registration module 502 may register an event that requires a callback by: the event registration module 502 receives the path of the Agent code, loads the Agent code, and registers the event that needs to be called back.
The device may also include an offload module 506 for offloading Agent codes. The device can also be used for receiving the control parameter and controlling the execution of the Agent code according to the control parameter.
While the present application has been described in connection with various embodiments, other variations to the disclosed embodiments can be understood and effected by those skilled in the art in practicing the claimed application, from a review of the drawings, the disclosure, and the appended claims. The terms "first," "second," and the like in the description and in the claims of the present application and in the above-described drawings are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It will be appreciated that the data so used may be interchanged under appropriate circumstances such that the embodiments described herein may be practiced otherwise than as specifically illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover non-exclusive inclusions, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus, the division of elements as presented herein is merely a logical division and may be implemented in a practical application in a different manner, such that multiple elements may be combined or integrated in another system or certain features may be omitted or not implemented, and such that an indirect or communicative coupling between the elements may be through interfaces or may be electrical or otherwise similar, are not intended to be limiting herein. Furthermore, the units or sub-units described as the separate components may or may not be physically separated, may or may not be physical units, or may not be divided into a plurality of circuit units, and some or all of the units may be selected according to actual needs to achieve the purpose of the embodiments of the present invention.
As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, apparatus (device), 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. A computer program stored/distributed on a suitable medium supplied together with or as part of other hardware, may also take other distributed forms, such as via the Internet or other wired or wireless telecommunication systems.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (devices) and computer program products according to embodiments of 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.
Although the present application has been described in conjunction with specific features and embodiments thereof, it will be evident that various modifications and combinations can be made thereto without departing from the spirit and scope of the application. Accordingly, the specification and figures are merely exemplary of the present application as defined in the appended claims and are intended to cover any and all modifications, variations, combinations, or equivalents within the scope of the present application. 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.
The technical solutions provided by the present invention are described in detail above, and the principle and the implementation of the present invention are explained in this document by applying specific examples, and the descriptions of the above examples are only used to help understanding the method and the core idea of the present invention; meanwhile, for a person skilled in the art, according to the idea of the present invention, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present invention.
Claims (11)
1. A method for acquiring process information, the method comprising:
the Python interpreter registers an event needing call back;
in the process of executing a Python process by the Python interpreter, when a registered event occurs, the Python interpreter triggers an event callback and outputs process information of the Python process;
the event that the Python interpreter registers that a callback is required comprises the following events:
the Python interpreter receives a path and a control parameter of an Agent code;
and the Python interpreter loads the Agent code, registers the event needing to be called back, and sets time and conditions for unloading the Agent code according to the control parameters.
2. The method of claim 1, further comprising: the Python interpreter offloads the Agent code.
3. The method of claim 1 or 2, further comprising:
and the Python interpreter controls the execution of the Agent code according to the control parameter.
4. An apparatus for obtaining process information, the apparatus comprising at least one processor and at least one memory, the at least one memory storing a computer program, the at least one processor configured to invoke program code in the at least one memory to perform the method of any of claims 1 to 3.
5. A computer storage medium having stored thereon computer software instructions that, when executed, cause a computer to perform the method of any of claims 1 to 3.
6. A device for acquiring process information is characterized in that a Python interpreter and a Python process are operated on the device, and the Python interpreter executes the Python process;
the Python interpreter is used for registering events needing call-back; when the registered event occurs, triggering an event call-back and outputting the process information of the Python process;
the Python interpreter registers events that need callbacks by:
the Python interpreter receives a path and a control parameter of an Agent code;
and the Python interpreter loads the Agent code, registers the event needing to be called back, and sets time and conditions for unloading the Agent code according to the control parameters.
7. The device according to claim 6, wherein the Python interpreter is further configured to offload the Agent code.
8. The device according to claim 6 or 7, the Python interpreter being further configured to control execution of the Agent code according to the control parameter.
9. An apparatus for acquiring process information, the apparatus comprising:
the event registration module is used for registering events needing to be called back;
the event call-back module is used for triggering event call-back and outputting the process information of the Python process when a registered event occurs in the process of executing the Python process by the Python interpreter;
the event registration module registers the event needing to be called back by the following method:
the event registration module receives a path and a control parameter of an Agent code;
and the event registration module loads the Agent code, registers the event needing to be called back, and sets time and conditions for unloading the Agent code according to the control parameters.
10. The device of claim 9, further comprising an offload module configured to offload the Agent code.
11. The device according to claim 9 or 10, further configured to control execution of Agent code according to the control parameter.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810015256.8A CN108197029B (en) | 2018-01-08 | 2018-01-08 | Method and device for acquiring process information |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810015256.8A CN108197029B (en) | 2018-01-08 | 2018-01-08 | Method and device for acquiring process information |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108197029A CN108197029A (en) | 2018-06-22 |
| CN108197029B true CN108197029B (en) | 2021-06-01 |
Family
ID=62588235
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810015256.8A Active CN108197029B (en) | 2018-01-08 | 2018-01-08 | Method and device for acquiring process information |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108197029B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112492193B (en) | 2019-09-12 | 2022-02-18 | 华为技术有限公司 | Method and equipment for processing callback stream |
| CN112732513B (en) * | 2019-10-28 | 2023-05-23 | 腾讯科技（深圳）有限公司 | Memory monitoring method, memory monitoring device, computer readable storage medium and computer equipment |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103905253A (en) * | 2014-04-04 | 2014-07-02 | 浪潮电子信息产业股份有限公司 | Server monitoring and management method based on Nagios and BMC |
| CN106445789A (en) * | 2016-10-11 | 2017-02-22 | 北京集奥聚合科技有限公司 | Monitoring visualizing method and system |
| WO2017176041A1 (en) * | 2016-04-04 | 2017-10-12 | 건국대학교 산학협력단 | Novel antimicrobial peptide isolated from python and method for discovering same |
-
2018
- 2018-01-08 CN CN201810015256.8A patent/CN108197029B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103905253A (en) * | 2014-04-04 | 2014-07-02 | 浪潮电子信息产业股份有限公司 | Server monitoring and management method based on Nagios and BMC |
| WO2017176041A1 (en) * | 2016-04-04 | 2017-10-12 | 건국대학교 산학협력단 | Novel antimicrobial peptide isolated from python and method for discovering same |
| CN106445789A (en) * | 2016-10-11 | 2017-02-22 | 北京集奥聚合科技有限公司 | Monitoring visualizing method and system |
Non-Patent Citations (1)
| Title |
|---|
| 深入Java调试体系，第2部分:JVMTI和Agent实现;张伟灿;《CSDN，https://blog.csdn.net/flyfish778/article/details/20466879》;20140304;第1-8页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108197029A (en) | 2018-06-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10467025B2 (en) | Managing delivery of code and dependent data using application containers | |
| US10789111B2 (en) | Message oriented middleware with integrated rules engine | |
| CN111209122B (en) | Interface calling method and device, electronic equipment and storage medium | |
| CN109656691A (en) | Processing method, device and the electronic equipment of computing resource | |
| US20210200607A1 (en) | Discovery and Chaining of Virtual Functions | |
| JP2021518955A (en) | Processor core scheduling method, equipment, terminals and storage media | |
| CN108197029B (en) | Method and device for acquiring process information | |
| CN111200606A (en) | Deep learning model task processing method, system, server and storage medium | |
| CN110659104B (en) | Service monitoring method and related equipment | |
| CN113282436A (en) | Event processing method, device, equipment and storage medium | |
| US11544589B2 (en) | Use machine learning to verify and modify a specification of an integration interface for a software module | |
| CN111611086A (en) | Information processing method, information processing apparatus, electronic device, and medium | |
| CN109905258B (en) | PaaS management method, device and storage medium | |
| US11689630B2 (en) | Request processing method and apparatus, electronic device, and computer storage medium | |
| CN114327087A (en) | Input event processing method and device, electronic equipment and storage medium | |
| CN110717992B (en) | Method, apparatus, computer system and readable storage medium for scheduling model | |
| CN110245027B (en) | Inter-process communication method and device | |
| CN110120963B (en) | Data processing method, device, equipment and machine readable medium | |
| US20150373078A1 (en) | On-demand helper operator for a streaming application | |
| CN111427654B (en) | Instruction processing method and device | |
| US10165074B2 (en) | Asynchronous custom exit points | |
| CN107463438B (en) | Information processing method, device and system for multi-Openstack environment | |
| CN112579282A (en) | Data processing method, device, system and computer readable storage medium | |
| CN110502891A (en) | A kind of method, apparatus, medium and electronic equipment obtaining proceeding internal memory leakage | |
| CN114168233B (en) | Data processing method, device, server and storage medium |
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 | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20220224 Address after: 550025 Huawei cloud data center, jiaoxinggong Road, Qianzhong Avenue, Gui'an New District, Guiyang City, Guizhou Province Patentee after: Huawei Cloud Computing Technologies Co.,Ltd. Address before: 518129 Bantian HUAWEI headquarters office building, Longgang District, Guangdong, Shenzhen Patentee before: HUAWEI TECHNOLOGIES Co.,Ltd. |
|
| TR01 | Transfer of patent right |