CN108243204B - Process running state display method and device - Google Patents
Process running state display method and device Download PDFInfo
- Publication number
- CN108243204B CN108243204B CN201611209004.6A CN201611209004A CN108243204B CN 108243204 B CN108243204 B CN 108243204B CN 201611209004 A CN201611209004 A CN 201611209004A CN 108243204 B CN108243204 B CN 108243204B
- Authority
- CN
- China
- Prior art keywords
- running state
- running
- query request
- occupancy rate
- storage area
- 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
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/10—Protocols in which an application is distributed across nodes in the network
- H04L67/1097—Protocols in which an application is distributed across nodes in the network for distributed storage of data in networks, e.g. transport arrangements for network file system [NFS], storage area networks [SAN] or network attached storage [NAS]
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
- G06F11/302—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system component is a software system
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3055—Monitoring arrangements for monitoring the status of the computing system or of the computing system component, e.g. monitoring if the computing system is on, off, available, not available
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/32—Monitoring with visual or acoustical indication of the functioning of the machine
- G06F11/324—Display of status information
- G06F11/328—Computer systems status display
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/10—Protocols in which an application is distributed across nodes in the network
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computing Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- Quality & Reliability (AREA)
- General Physics & Mathematics (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Computer Hardware Design (AREA)
- Mathematical Physics (AREA)
- Computer And Data Communications (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention provides a method and a device for displaying a process running state, wherein the method comprises the following steps: receiving a process running state query request sent by a client; acquiring the running state of the corresponding process based on the process state query request; and generating information to be displayed of the process running state according to the running state, and sending the information to be displayed to a client for displaying the process running state to a user. According to the technical scheme, a user, namely a programmer can know the running state of the compiler corresponding to the process through the client, so that the workload of a manager of the distributed storage system for transferring the running state of the compiler corresponding to the process to each programmer is reduced.
Description
Technical Field
The invention relates to the field of big data, in particular to a method and a device for displaying a process running state.
Background
With the development of the internet, the wave of big data technology is rolling the world, becoming a new productivity technology. The big data technology not only means obtaining mass data, but also has more important significance in obtaining valuable information hidden behind the data through analysis and integration of the mass data.
The large data is characterized by a large amount of data, so that a great challenge is faced when the large data is subjected to storage management, and the problem can be solved by a distributed storage technology. The distributed storage technology is to store large data on a device cluster formed by a plurality of independent devices in a distributed storage system in a scattered manner. Because the distributed storage system adopts an expandable system structure, a plurality of independent storage servers are used for sharing storage load, and the position server is used for positioning storage information, the reliability, the availability and the access efficiency of the distributed storage system are improved, and the expansion is easy.
In order to better enable the distributed storage system to analyze and process the big data, a programmer needs to compile a program on a data processing engine of the distributed storage system and submit the compiled program to an operating system of the distributed storage system, and the operating system provides a running environment for the compiled program so as to run the compiled program. However, because the distributed storage system has a permission problem, a programmer cannot know the running state of the compiled program in the operating system and the program bug of the compiled program because the programmer does not have administrator permission, so that the programmer needs to ask an administrator of the distributed storage system to know the running state of the compiled program. However, querying an administrator of the distributed system to know the running state of the compiled program causes a huge workload for the administrator, and may not meet the requirements of all programmers. Therefore, how to enable the programmer to autonomously acquire the running state of the compiled program is a key for solving the above problems.
Disclosure of Invention
In order to overcome the above technical problems or at least partially solve the above technical problems, the following technical solutions are proposed:
the embodiment of the invention provides a method for displaying a process running state, which comprises the following steps:
receiving a process running state query request sent by a client;
acquiring the running state of a corresponding process based on the process state query request;
and generating information to be displayed of the process running state according to the running state, and sending the information to be displayed to the client for displaying the process running state to the user.
Preferably, the step of acquiring the running state of the corresponding process based on the process state query request specifically includes:
and acquiring the running states of all running processes based on the process running state query request.
Preferably, the method further comprises:
monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
Preferably, the step of acquiring the running state of the corresponding process based on the process state query request specifically includes:
and acquiring the running states of all running processes from a preset storage area based on the process running state query request.
Preferably, when the process running state query request includes a query keyword, the step of obtaining the running state of the corresponding process based on the process running state query request specifically includes:
and acquiring the running state of the process matched with the query keyword based on the query keyword.
Wherein the running state of the process comprises at least one of the following:
memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
Another embodiment of the present invention provides an apparatus for displaying a process running state, including:
the receiving module is used for receiving a process running state query request sent by a client;
the acquisition module is used for acquiring the running state of the corresponding process based on the process state query request;
and the display module is used for generating information to be displayed of the process running state according to the running state and sending the information to be displayed to the client so as to display the process running state to the user.
Preferably, the obtaining module is configured to obtain the running states of all running processes based on the process running state query request.
Preferably, the apparatus further comprises:
and the monitoring module is used for monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
Preferably, the obtaining module is further configured to obtain the running states of all running processes from the preset storage area based on the process running state query request.
Preferably, when the process running state query request includes a query keyword, the obtaining module is further configured to obtain, based on the query keyword, a running state of the process matched with the query keyword.
Wherein the running state of the process comprises at least one of the following:
memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
In the technical scheme of the invention, the running state of the corresponding process is acquired based on the process state query request sent by the receiving client, the information to be displayed of the process running state is generated according to the running state, and the information to be displayed is sent to the client for displaying, so that a user, namely a programmer can know the running state of the compiler corresponding to the process through the client, and the workload of a manager of the distributed storage system for transferring the running state of the compiler corresponding to the process to each programmer is reduced; and a powerful precondition guarantee is provided for the programmer to further estimate the compiling quality of the compiler and the program bugs of the compiler based on the known running state of the compiler corresponding to the process, and finally the modification of the compiler aiming at the program bugs of the compiler can be realized, so that the quality of the modified compiler is improved, and the performance of processing and analyzing big data of the distributed storage system is improved.
Additional aspects and advantages of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.
Drawings
The foregoing and/or additional aspects and advantages of the present invention will become apparent and readily appreciated from the following description of the embodiments, taken in conjunction with the accompanying drawings of which:
fig. 1 is a flowchart illustrating a method for displaying a process running state according to an embodiment of the present invention;
fig. 2 is a structural framework diagram of a process operation status display device according to another embodiment of the present invention.
Detailed Description
Reference will now be made in detail to embodiments of the present invention, examples of which are illustrated in the accompanying drawings, wherein like or similar reference numerals refer to the same or similar elements or elements having the same or similar function throughout. The embodiments described below with reference to the drawings are illustrative only and should not be construed as limiting the invention.
As used herein, the singular forms "a", "an", "the" and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and/or "comprising," when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element or intervening elements may also be present. Further, "connected" or "coupled" as used herein may include wirelessly connected or wirelessly coupled. As used herein, the term "and/or" includes all or any element and all combinations of one or more of the associated listed items.
It will be understood by those skilled in the art that, unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs. It will be further understood that terms, such as those defined in commonly used dictionaries, should be interpreted as having a meaning that is consistent with their meaning in the context of the prior art and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein.
Fig. 1 is a flowchart illustrating a method for displaying a process running state according to an embodiment of the present invention.
The execution agent of the present embodiment is a server.
Step S101: receiving a process running state query request sent by a client; step S102: acquiring the running state of a corresponding process based on the process state query request; step S103: and generating information to be displayed of the process running state according to the running state, and sending the information to be displayed to the client for displaying the process running state to the user.
In the technical scheme of the invention, the running state of the corresponding process is acquired based on the process state query request sent by the receiving client, the information to be displayed of the process running state is generated according to the running state, and the information to be displayed is sent to the client for displaying, so that a user, namely a programmer can know the running state of the compiler corresponding to the process through the client, and the workload of a manager of the distributed storage system for transferring the running state of the compiler corresponding to the process to each programmer is reduced; and a powerful precondition guarantee is provided for the programmer to further estimate the compiling quality of the compiler and the program bugs of the compiler based on the known running state of the compiler corresponding to the process, and finally the modification of the compiler aiming at the program bugs of the compiler can be realized, so that the quality of the modified compiler is improved, and the performance of processing and analyzing big data of the distributed storage system is improved.
The following further explains the specific implementation of each step:
step S101: and receiving a process running state query request sent by a client.
Specifically, the server receives a process running state query request sent by the web page client. The process running state query request may include a query keyword, for example, the query keyword includes a "job id 001" or may not include the query keyword; when the process running state query request does not contain the query keyword, the return information of the server responding to the process running state query request contains the obtained running states of all the processes.
Step S102: and acquiring the running state of the corresponding process based on the process state query request.
Wherein the running state of the process comprises at least one of the following: memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
Specifically, when the state query request of the process does not include the query keyword, the step of obtaining the running state of the corresponding process based on the process state query request specifically includes: and acquiring the running states of all running processes based on the process running state query request.
For example, the server obtains the running states of all running programs or processes of tasks through a running state query instruction based on a process running state query request, and the running states of any task or process of a program, such as: task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: (viii)/usr/bin/gstack; the acquired call stack is displayed through a soft link, and a user can see specific information about the task000 call stack by clicking the soft link.
It should be noted that, a user submits at least one job to a server through a web client, where the job includes multiple task tasks or programs, and the server provides a running environment for all task tasks or programs in the job to run all task tasks or programs.
Specifically, the method further comprises: monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
For example, the server monitors all running tasks or processes of the program, and when the server monitors that the running state of any running task or process of the program changes, for example, the server monitors that the task 000: memory occupancy rate during process operation: changing from 10% to 12%; the server captures the running state of the running process of any task or program after updating, for example, the memory occupancy rate of the running process of task000 after updating: 12%, grabbing; and updating and storing the captured running state of the process of any running task or program into a preset storage area, for example, the memory occupancy rate of the process of the task000 after the process of the captured running task is updated during running is as follows: 12% and storing the data in a server resource pool.
Specifically, the step of acquiring the running state of the corresponding process based on the process state query request specifically includes: and acquiring the running states of all running processes from a preset storage area based on the process running state query request.
For example, the server acquires the running states of all running processes from the server resource pool based on the process running state query request.
It should be noted that, the status query request in the preferred embodiment does not include a query keyword, and the running status of all running processes can be effectively and quickly obtained from the server resource pool.
Specifically, when the process running state query request includes a query keyword, the step of obtaining the running state of the corresponding process based on the process running state query request specifically includes: and acquiring the running state of the process matched with the query keyword based on the query keyword.
For example, when a process running state query request includes a query keyword, for example, "task id ═ 000", the server obtains, through a running state query instruction, a running state of a process matching the query keyword "task id ═ 000", that is, a running state of a process having task id ═ 000, for example, task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: and/usr/bin/gstack. Or, the server searches the running state of the process matching the query keyword "task id 000", that is, the running state of the process having task id 000, from the resource pool, for example, task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: and/usr/bin/gstack.
Step S103: and generating information to be displayed of the process running state according to the running state, and sending the information to be displayed to the client for displaying the process running state to the user.
The server generates process running state information to be displayed according to a preset display mode and a display arrangement format based on the running state, and the process running state information to be displayed is as follows:
Job 000：
task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: usr/bin/gstack
……
Task 009: memory occupancy rate during process operation: 12%, CPU utilization: 5% and input/output IO occupancy: 10% and network occupancy rate: 2%, call stack: usr/bin/gstack
Job 001：
Task 000: memory occupancy rate during process operation: 10%, CPU utilization: 12% input/output IO occupancy: 15% and network occupancy rate: 5%, call stack: usr/bin/gstack
……
Task 008: memory occupancy rate during process operation: 8%, CPU utilization: 10% input/output IO occupancy: 10% and network occupancy rate: 2%, call stack: usr/bin/gstack
……
Job 010：
Task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 10% and network occupancy rate: 5%, call stack: usr/bin/gstack
……
Task 008: memory occupancy rate during process operation: 10%, CPU utilization: 12% input/output IO occupancy: 10% and network occupancy rate: 5%, call stack: usr/bin/gstack
And the server sends the information to be displayed to the client so as to display the process running state to the user.
Fig. 2 is a structural framework diagram of a process operation status display device according to another embodiment of the present invention.
A receiving module 201, configured to receive a process running state query request sent by a client; an obtaining module 202, configured to obtain an operating state of a corresponding process based on the process state query request; the display module 203 generates information to be displayed of the process running state according to the running state, and sends the information to be displayed to the client, so as to display the process running state to the user.
The following further explains the specific implementation of each step:
the receiving module 201 receives a process running state query request sent by a client.
Specifically, the receiving module 201 of the server receives a process running state query request sent by a web client. The process running state query request may include a query keyword, for example, the query keyword includes a "job id 001" or may not include the query keyword; when the process running state query request does not contain the query keyword, the return information of the server responding to the process running state query request contains the obtained running states of all the processes.
The obtaining module 202 obtains the running state of the corresponding process based on the process state query request.
Wherein the running state of the process comprises at least one of the following: memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
Specifically, when the state query request of the process does not include the query keyword, the obtaining module 202 obtains the running states of all running processes based on the process running state query request.
For example, the obtaining module 202 of the server obtains, based on the process running state query request, the running states of all running programs or processes of tasks, the running states of any task or process of programs through the running state query instruction, such as: task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: (viii)/usr/bin/gstack; the acquired call stack is displayed through a soft link, and a user can see specific information about the task000 call stack by clicking the soft link.
It should be noted that, a user submits at least one job to a server through a web client, where the job includes multiple task tasks or programs, and the server provides a running environment for all task tasks or programs in the job to run all task tasks or programs.
Specifically, the apparatus further comprises: and the monitoring module is used for monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
For example, the server monitoring module monitors all running tasks or processes of programs, and when the server monitors that the running state of any running task or process of a program changes, for example, the server monitors that the task 000: memory occupancy rate during process operation: changing from 10% to 12%; the server captures the running state of the running process of any task or program after updating, for example, the memory occupancy rate of the running process of task000 after updating: 12%, grabbing; and updating and storing the captured running state of the process of any running task or program into a preset storage area, for example, the memory occupancy rate of the process of the task000 after the process of the captured running task is updated during running is as follows: 12% and storing the data in a server resource pool.
Specifically, the obtaining module 202 further obtains the running states of all running processes from the preset storage area based on the process running state query request.
For example, the obtaining module 202 of the server obtains the running states of all running processes from the server resource pool based on the process running state query request.
It should be noted that, the status query request in the preferred embodiment does not include a query keyword, and the running status of all running processes can be effectively and quickly obtained from the server resource pool.
Specifically, when the process running state query request includes a query keyword, the obtaining module 202 further obtains the running state of the process matching the query keyword based on the query keyword.
For example, when a process running state query request includes a query keyword, for example, "task id ═ 000", the obtaining module 202 of the server obtains, through a running state query instruction, a running state of a process matching the query keyword "task id ═ 000", that is, a running state of a process having task id ═ 000, for example, task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: and/usr/bin/gstack. Or, the obtaining module 202 of the server searches for the running state of the process matching the query keyword "task id 000", that is, the running state of the process having task id 000, from the resource pool, for example, task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: and/usr/bin/gstack.
The display module 203 generates information to be displayed of the process running state according to the running state, and sends the information to be displayed to the client, so as to display the process running state to the user.
The display module 103 of the server generates the information to be displayed of the process running state according to the predetermined display mode and the display arrangement format based on the running state, as follows:
Job 000：
task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 15% and network occupancy rate: 2%, call stack: usr/bin/gstack
……
Task 009: memory occupancy rate during process operation: 12%, CPU utilization: 5% and input/output IO occupancy: 10% and network occupancy rate: 2%, call stack: usr/bin/gstack
Job 001：
Task 000: memory occupancy rate during process operation: 10%, CPU utilization: 12% input/output IO occupancy: 15% and network occupancy rate: 5%, call stack: usr/bin/gstack
……
Task 008: memory occupancy rate during process operation: 8%, CPU utilization: 10% input/output IO occupancy: 10% and network occupancy rate: 2%, call stack: usr/bin/gstack
……
Job 010：
Task 000: memory occupancy rate during process operation: 10%, CPU utilization: 10% input/output IO occupancy: 10% and network occupancy rate: 5%, call stack: usr/bin/gstack
……
Task 008: memory occupancy rate during process operation: 10%, CPU utilization: 12% input/output IO occupancy: 10% and network occupancy rate: 5%, call stack: usr/bin/gstack
And the server sends the information to be displayed to the client so as to display the process running state to the user.
Those skilled in the art will appreciate that the present invention includes apparatus directed to performing one or more of the operations described in the present application. These devices may be specially designed and manufactured for the required purposes, or they may comprise known devices in general-purpose computers. These devices have stored therein computer programs that are selectively activated or reconfigured. Such a computer program may be stored in a device (e.g., computer) readable medium, including, but not limited to, any type of disk including floppy disks, hard disks, optical disks, CD-ROMs, and magnetic-optical disks, ROMs (Read-Only memories), RAMs (Random Access memories), EPROMs (Erasable Programmable Read-Only memories), EEPROMs (Electrically Erasable Programmable Read-Only memories), flash memories, magnetic cards, or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a bus. That is, a readable medium includes any medium that stores or transmits information in a form readable by a device (e.g., a computer).
It will be understood by those within the art that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by computer program instructions. Those skilled in the art will appreciate that the computer program instructions may be implemented by a processor of a general purpose computer, special purpose computer, 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, implement the features specified in the block or blocks of the block diagrams and/or flowchart illustrations of the present disclosure.
Those of skill in the art will appreciate that various operations, methods, steps in the processes, acts, or solutions discussed in the present application may be alternated, modified, combined, or deleted. Further, various operations, methods, steps in the flows, which have been discussed in the present application, may be interchanged, modified, rearranged, decomposed, combined, or eliminated. Further, steps, measures, schemes in the various operations, methods, procedures disclosed in the prior art and the present invention can also be alternated, changed, rearranged, decomposed, combined, or deleted.
The foregoing is only a partial embodiment of the present invention, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present invention, and these modifications and decorations should also be regarded as the protection scope of the present invention.
Claims (10)
1. A method for displaying a process running state comprises the following steps:
receiving a process running state query request sent by a client;
acquiring the running state of a corresponding process based on the process running state query request in a preset storage area, wherein the running state of all running processes is stored in the preset storage area;
generating information to be displayed of the process running state according to the running state, and sending the information to be displayed to a client for displaying the process running state to a user;
the process running state query request does not contain query keywords, and the process running state query request based on the process running state is used for acquiring the running state of the corresponding process, and the process running state query request comprises the following steps:
and acquiring the running states of all running processes based on the process running state query request.
2. The method of claim 1, further comprising:
monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
3. The method according to claim 2, wherein the step of obtaining the running state of the corresponding process based on the process state query request specifically includes:
and acquiring the running states of all running processes from the preset storage area based on the process running state query request.
4. The method according to claim 1, wherein, when the process running state query request includes a query keyword, the step of obtaining the running state of the corresponding process based on the process running state query request specifically includes:
and acquiring the running state of the process matched with the query keyword based on the query keyword.
5. The method of any of claims 1-4, wherein the running state of the process comprises at least one of:
memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
6. A process running state display device comprises:
the receiving module is used for receiving a process running state query request sent by a client;
the acquisition module is used for acquiring the running state of the corresponding process based on the process running state query request in a preset storage area, and the preset storage area stores the running states of all running processes;
the display module is used for generating information to be displayed of the process running state according to the running state and sending the information to be displayed to the client so as to display the process running state to a user;
the process running state query request does not contain query keywords, and the acquisition module is specifically used for acquiring the running states of all running processes in a preset storage area based on the process running state query request.
7. The apparatus of claim 6, further comprising:
and the monitoring module is used for monitoring all running processes, capturing the updated running state of any running process when the running state change of any running process is monitored, and updating and storing the captured running state of any running process into a preset storage area.
8. The apparatus according to claim 7, wherein the obtaining module is further configured to obtain the running states of all running processes from the preset storage area based on the process running state query request.
9. The apparatus of claim 6, wherein when the process running state query request includes a query keyword, the obtaining module is further configured to obtain the running state of the process matching the query keyword based on the query keyword.
10. The apparatus of any of claims 6-9, wherein the running state of the process comprises at least one of:
memory occupancy rate, CPU utilization rate, input/output (IO) occupancy rate, network occupancy rate and call stack when the process runs.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201611209004.6A CN108243204B (en) | 2016-12-23 | 2016-12-23 | Process running state display method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201611209004.6A CN108243204B (en) | 2016-12-23 | 2016-12-23 | Process running state display method and device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN108243204A CN108243204A (en) | 2018-07-03 |
| CN108243204B true CN108243204B (en) | 2021-06-18 |
Family
ID=62704328
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201611209004.6A Active CN108243204B (en) | 2016-12-23 | 2016-12-23 | Process running state display method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN108243204B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111124923B (en) * | 2019-12-25 | 2024-03-22 | 上海米哈游网络科技股份有限公司 | Running state query method and device, server equipment and storage medium |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1679602A1 (en) * | 2004-12-28 | 2006-07-12 | Sap Ag | Shared memory based monitoring for application servers |
| CN102521099A (en) * | 2011-11-24 | 2012-06-27 | 深圳市同洲视讯传媒有限公司 | Process monitoring method and process monitoring system |
| CN104620539A (en) * | 2012-06-15 | 2015-05-13 | 思杰系统有限公司 | Systems and methods for supporting a SNMP request over a cluster |
| CN105512027A (en) * | 2015-11-26 | 2016-04-20 | 珠海多玩信息技术有限公司 | Process state monitor method and device |
| CN105871998A (en) * | 2015-12-18 | 2016-08-17 | 乐视致新电子科技（天津）有限公司 | Data displaying method and device |
| CN105930249A (en) * | 2016-04-20 | 2016-09-07 | 百度在线网络技术（北京）有限公司 | Application monitoring method and apparatus |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8707194B1 (en) * | 2009-11-20 | 2014-04-22 | Amazon Technologies, Inc. | System and method for decentralized performance monitoring of host systems |
-
2016
- 2016-12-23 CN CN201611209004.6A patent/CN108243204B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1679602A1 (en) * | 2004-12-28 | 2006-07-12 | Sap Ag | Shared memory based monitoring for application servers |
| CN102521099A (en) * | 2011-11-24 | 2012-06-27 | 深圳市同洲视讯传媒有限公司 | Process monitoring method and process monitoring system |
| CN104620539A (en) * | 2012-06-15 | 2015-05-13 | 思杰系统有限公司 | Systems and methods for supporting a SNMP request over a cluster |
| CN105512027A (en) * | 2015-11-26 | 2016-04-20 | 珠海多玩信息技术有限公司 | Process state monitor method and device |
| CN105871998A (en) * | 2015-12-18 | 2016-08-17 | 乐视致新电子科技（天津）有限公司 | Data displaying method and device |
| CN105930249A (en) * | 2016-04-20 | 2016-09-07 | 百度在线网络技术（北京）有限公司 | Application monitoring method and apparatus |
Also Published As
| Publication number | Publication date |
|---|---|
| CN108243204A (en) | 2018-07-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110417613B (en) | Distributed performance testing method, device, equipment and storage medium based on Jmeter | |
| Deelman et al. | Pegasus, a workflow management system for science automation | |
| De Oliveira et al. | Scicumulus: A lightweight cloud middleware to explore many task computing paradigm in scientific workflows | |
| AU2021203955B2 (en) | Dynamic component performance monitoring | |
| EP3226133A1 (en) | Task scheduling and resource provisioning system and method | |
| US8214809B2 (en) | Grid-enabled ANT compatible with both stand-alone and grid-based computing systems | |
| Shu et al. | Massive distributed and parallel log analysis for organizational security | |
| EP2696297B1 (en) | System and method for generating information file based on parallel processing | |
| CN109614227A (en) | Task resource concocting method, device, electronic equipment and computer-readable medium | |
| Wu et al. | Modeling of distributed file systems for practical performance analysis | |
| Oldfield et al. | Evaluation of methods to integrate analysis into a large-scale shock shock physics code | |
| US7444350B1 (en) | Method and apparatus for processing management information | |
| CN116304233A (en) | Telemetry target query injection for enhanced debugging in a micro-service architecture | |
| Zhao et al. | Evaluation and analysis of distributed graph-parallel processing frameworks | |
| Papadimitriou et al. | End-to-end online performance data capture and analysis for scientific workflows | |
| EP2634699B1 (en) | Application monitoring | |
| Walker et al. | Challenges in executing large parameter sweep studies across widely distributed computing environments | |
| Shan et al. | KubeAdaptor: a docking framework for workflow containerization on Kubernetes | |
| US20100269119A1 (en) | Event-based dynamic resource provisioning | |
| CN108243204B (en) | Process running state display method and device | |
| Rosales et al. | Remora: a resource monitoring tool for everyone | |
| Liu et al. | Supporting fault-tolerance in presence of in-situ analytics | |
| Warrender et al. | Job scheduling in a high performance computing environment | |
| Anghel et al. | Quantifying communication in graph analytics | |
| Silva et al. | Adding domain data to code profiling tools to debug workflow parallel execution |
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 |