If you don't remember your password, you can reset it by entering your email address and clicking the Reset Password button. You will then receive an email that contains a secure link for resetting your password
If the address matches a valid account an email will be sent to __email__ with instructions for resetting your password
ProcessPerformance is a tool to measure resource consumption of running processes.
•
It provides information about the utilization of CPU, memory and network resources.
•
ProcessPerformance is as an easy-to-use command-line tool.
•
It is implemented for the .Net Core platform, which runs in most operating systems.
•
It has been used in many projects to measure the efficiency of complex systems.
Abstract
The measurement of the resources consumed by an application at runtime is an important task in different scenarios such as program optimization, malware and bug detection, and hardware scaling. Although different tools exist for this purpose, they sometimes show some limitations such as operating system and hardware dependencies, performance overhead, and usage complexity. For this reason, we create ProcessPerformance, a portable and easy-to-use command-line tool that provides information about the CPU, memory, and network resources consumed by any combination of running processes. It also avoids the performance overhead caused by software and binary code injection.
]. That measurement is a valuable piece of information to optimize applications consuming too many resources, scale the hardware resources depending on the running processes, identify potential malicious programs, and compare resource consumption of different processes [
V. Salapura, K. Ganesan, A. Gara, M. Gschwind, J.C. Sexton, R.E. Walkup, Next-Generation Performance Counters: Towards Monitoring Over Thousand Concurrent Events, in: ISPASS 2008 - IEEE International Symposium On Performance Analysis Of Systems And Software, 2008, pp. 139–146.
]. Resource consumption data are usually collected by hardware monitors, additional routines implemented at the operating system level, or code injected in a program [
]. The choice of a measurement technique depends on different factors, such as the data to be measured, the potential impact of the measurement tools on the performance of the whole application, and the available hardware and software resources, among others [
]. Task managers are system monitor programs that provide information about computer performance, including the name of running processes, CPU and GPU load, I/O information, logged-in users, and operating system services [
]. These task managers provide a graphical user interface to give information to the user, but they do not facilitate the extraction of the data measured. On the contrary, tasklist [
] are textual command-line task managers that make it easier to retrieve that information. iotop and nethogs only provide network information, and none of those tools support Windows, Linux, and macOS.
Software instrumentation tools add pieces of code around source or binary code to measure dynamic resource consumption [
L. Uhsadel, A. Georges, I. Verbauwhede, Exploiting Hardware Performance Counters, in: 5th Workshop On Fault Diagnosis And Tolerance In Cryptography, 2008, pp. 59–67.
]. HPC is based on hardware counters that register microprocessor activities upon the trace generation phase. Later, that information can be analyzed by tools such as Windows Reliability and Performance Monitor (perfmon) [
]. The main benefit of HPCs compared to software-based approaches is that HPCs provide lower performance overhead to obtain detailed performance information, but they are hardware-dependent [
Some other approaches are based on modifying the behavior of the virtual machine that is used to run the software. The Java Management Extensions (JMX) framework provides a configurable mechanism for managing and monitoring Java applications [
]. With Managed Beams (MBeans), programs can be instrumented to measure the runtime resources consumed by the application. Likewise, dotnet-trace is a .Net application that enables the collection of application traces without a native profiler [
]. These kinds of tools provide runtime information about runtime resource consumption, but only for applications executed on particular virtual machines.
Process and System Utilities (psutil) is a cross-platform library for retrieving information of running processes, such as CPU, memory, disks, and network consumption [
]. It is written in Python 3.4 and aims to monitor and profile systems. It supports most operating systems. psutils is delivered as an API, so users must write their own programs to visualize the resource consumption of running programs.
In this paper, we present ProcessPerformance, an open-source multi-platform tool to monitor and retrieve the CPU, memory, and network resources consumed by any combination of running processes. Runtime process instrumentation is performed at the operating-system level, so no overhead is produced by high-level source code instrumentation. HPC information may be used by the operating software when the hardware supports HPC, causing almost no runtime overhead [
]. ProcessPerformance is implemented in the free open-source .Net Core platform that runs on Windows, Linux, and macOS. It provides an easy-to-use command-line interface that does not require the subsequent analysis of tracing log information. The services of ProcessPerformance can be used by any other application, since its source code is available for download at https://github.com/ComputationalReflection/ProcessPerformance.
2. Application description and functions
ProcessPerformance is designed to easily provide information about the resources consumed by any processes. It retrieves information about the CPU, memory, and network resource consumption during a period of time. ProcessPerformance is a portable open-source application implemented for the .Net Core platform. Memory and CPU usage is measured with the Process class in the System.Diagnostics namespace, which supports interaction with local and remote processes, event logs, and performance counters [
] that allows us to collect and process event data of the processes running on the operating system. To get the information of the overall network traffic, ProcessPerformance uses the NetworkInterface class that provides configuration and statistical information for a network interface.
What follows is a brief description of how ProcessPerformance gathers resource consumption information from the operating system, as illustrated in Fig. 1:
Fig. 1Gathering resource consumption information from the operating system. (For interpretation of the references to color in this figure legend, the reader is referred to the web version of this article.)
CPU consumption, measured as the percentage of use of the total CPU resources. It is computed with the following equation:
(1)
The first operand is the TotalProcessorTime property of the Process class, which returns the time that the microprocessor spends working on a task (it is the sum of user and privileged processor time) [
]. Processor times are represented as blue rectangles in Fig. 1. Clock time is the elapsed execution time for the time interval measured (i.e., in Fig. 1). The division of these two values gives us the percentage of CPU used by the process. That value is then divided by the number of system cores (the ProcessorCount property of the Environment class) to obtain the CPU consumption, because TotalProcessorTime represents the sum of working times for all the cores.
•
Overall network traffic refers to the number of bytes transferred across the network by all the processes since ProcessPerformance is executed. The GetIPv4Statistics method is used to get that information from the operating system, including the bytes sent (BytesSent property of IPv4InterfaceStatistics, shown as dark green rectangles in Fig. 1) and received (BytesReceived property, shown as light green rectangles in Fig. 1). With this information, ProcessPerformance displays both the number of bytes transferred and the transmission rate.
•
Process network consumption is the number of bytes transferred by one single process across the network since ProcessPerformance started measuring. A TraceEventSession object is used to register all the TCP/IP events triggered in the system. It follows the Observer design pattern, where listeners are registered to be notified when different events occur [
]. ProcessPerformance registers itself for the TcpIpRecv and TcpIpSend events to store the information about data received and sent. Each time one of these two events is triggered, we check whether the process causing the data transfer is the one to be monitored and, if so, we update the variables counting the number of bytes transmitted by that process. Fig. 1 shows the data sent by a process with dark gray rectangles, while light gray boxes represent the data received.
•
Memory consumption. To measure the memory consumed by a process at runtime, we count the maximum size of working set memory used by a process (i.e., the PeakWorkingSet property of Process [
]). The working set of a process is the set of memory pages currently visible to the process in physical RAM memory. Those pages are resident and available for an application to be used without triggering a page fault. The working set includes both shared and private data. The shared data comprises the pages that contain all the instructions that the process executes, including those from the process modules and the system libraries. As shown in Fig. 1, it is common that the working set memory used by a process grows at runtime as the program demands more memory from the operating system.
Fig. 2Output for ProcessPerformance chrome -interval:500.
In Windows, the application is directly run with ProcessPerformance. In Unix-based operating systems, it must be written dotnet ProcessPerformance.dll.
ProcessPerformance -help the following command-line options are described:
•
. A space-separated list of the names or PIDs (process identifiers) of the processes to be monitored. If no process is passed, the overall system resources are displayed.
•
-interval:milliseconds. The interval used to gather the runtime information of resource consumption, expressed in milliseconds. The default value is 1,000 (one second).
•
-network:IP_address. IP address of the network interface used to measure data transmission.
•
-csv. Shows the output in comma-separated values (CSV) format.
•
-help. Describes the different command-line arguments.
For example, the following command shows the CPU, memory, and network resources consumed by the Chrome web browser, every half second: ProcessPerformance chrome -interval:500. That command produces the output displayed in Fig. 2, where ProcessPerformance tells us that there are four different processes running Chrome, and displays the resources consumed by the four processes.
ProcessPerformance allows measuring the resources consumed by a complex application or system, defined as a collection of running programs. Therefore, the following command can be used to measure overall resources used by a client–server application that runs an application server (Apache Tomcat), two persistence systems (PostgreSQL and Neo4j), and the Chrome web browser as a client:
The output is shown in Fig. 3. The network traffic is displayed with two values: the sum of all the data transferred by the 22 processes (4 programs), and the data transmitted through the 192.168.137.2 network interface.
Fig. 3Output for ProcessPerformance chrome tomcat neo4j postgres -interval:500 -network:192.168.137.2.
When measuring the resources consumed by an application at runtime, it is important to define a statistically rigorous methodology and the correct use of tools [
in: Proceedings Of The 22nd Annual ACM SIGPLAN Conference On Object-Oriented Programming Systems And Applications. OOPSLA. ACM,
New York, NY, USA2007: 57-76
]. The characteristics of ProcessPerformance have made it a valuable tool to measure the runtime resources consumed by many kinds of applications. In the scenario of comparing techniques for the implementation of programming languages, ProcessPerformance has been used to measure runtime execution and memory consumption of program specialization [
In the scenario of aspect-oriented programming (AOP) ProcessPerformance has been utilized to compare the efficiency of dynamic and static weavers for the Java [
Likewise, our tool has measured memory and CPU consumption of various virtual machine implementations, such as the addition of structural intercession [
]. ProcessPerformance has been used to measure network and memory consumption in the design and implementation of mobile applications for multiple platforms [
]. In this case, various applications were measured together, since the system comprises different processes. ProcessPerformance was a helpful tool to know the network traffic generated by the entire system, which was a critical aspect due to the limited Internet connections the students have in their households [
ProcessPerformance has also been utilized to measure training and inference time of machine learning models in different scenarios such as programmer classification [
As mentioned in Section 2, ProcessPerformance uses the TraceEvent library to know the data sent and received by a particular process. TraceEvent was originally designed to parse the Event Tracing for Windows (ETW) events generated by the Windows operating system. Thus, ProcessPerformance only provides this particular information when run on a Windows operating systems. However, it is worth noting that the traffic information of the overall network is provided for any operating system.
Declaration of Competing Interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Acknowledgments
This work has been partially funded by the Spanish Department of Science, Innovation and Universities: project RTI2018-099235-B-I00. The authors have also received funds from the University of Oviedo, Spain
through its support to official research groups (GR-2011-0040).
V. Salapura, K. Ganesan, A. Gara, M. Gschwind, J.C. Sexton, R.E. Walkup, Next-Generation Performance Counters: Towards Monitoring Over Thousand Concurrent Events, in: ISPASS 2008 - IEEE International Symposium On Performance Analysis Of Systems And Software, 2008, pp. 139–146.
L. Uhsadel, A. Georges, I. Verbauwhede, Exploiting Hardware Performance Counters, in: 5th Workshop On Fault Diagnosis And Tolerance In Cryptography, 2008, pp. 59–67.
in: Proceedings Of The 22nd Annual ACM SIGPLAN Conference On Object-Oriented Programming Systems And Applications. OOPSLA. ACM,
New York, NY, USA2007: 57-76
00002-1&id=gr1.jpg){kind=link}
00002-1&id=gr2.jpg){kind=link}
00002-1&id=gr3.jpg){kind=link}