Shulou(Shulou.com)06/01 Report--

This article mainly explains "using Time statistics program running time on Linux", the content of the article is simple and clear, easy to learn and understand, the following please follow the editor's train of thought slowly in depth, together to study and learn "using Time statistics program running time on Linux"!

1 detailed explanation of basic usage

First, let's take a look at the most basic usage, which is probably the most common one.

Root@chopin:~$ time find. -name "chopin.txt". Real 0m0.174s user 0m0.084s sys 0m0.084s

You can clearly see that the execution time of the find command is 0.174s. Is it very simple and convenient?

However, the time command outputs three parameters, and we only use the first one. What do the other two parameters mean?

Let me explain here:

Real: it means the time on the wall. To put it bluntly, it is the time from the beginning to the end of the program.

User: indicates the time that cpu spends in user mode while the program is running

Sys: indicates the time spent in the kernel state of cpu while the program is running

Careful readers will find that user + sys in the above case is not equal to real. What is going on?

In fact, the user and sys explained above are the time taken by cpu to execute instructions, and do not include: process blocking IO, scheduling queue, these non-cpu runtime.

In the case of find, during the process of searching for files, disk IO will be read, and cpu will be released to do other things. The time consumed by IO is not included in user and sys statistics, so it appears that real time is greater than user + sys.

Another example is used to verify and strengthen our understanding.

Root@chopin:~$ time sleep 2 real 0m2.001s user 0m0.000s sys 0m0.000s

You can clearly see that the sleep command basically does not consume cpu, and the real running time of the program is 2 seconds.

Then can we come to the following conclusion:

Real > = user + sys

In fact, this conclusion is correct in the case of a single cpu.

If the server is multiple cpu, your program can make full use of multiple cpu, and the program runs in parallel with multiple cores, then the cpu time counted by user + sys may be greater than the real time.

So the relationship between these three times is not constant, you need to know clearly whether the server is multiple cores.

Through the statistics of the cpu elapsed time, we can also get a general idea of the cpu utilization during the running of the program. For single-core, compute-intensive programs, real will be very close to the sum of user and sys time.

Tips: some students may not be familiar with the operating system. Here are the basic concepts of kernel state and user state under popular science.

In order to make the system more stable, Linux adopts the measures of isolation and protection, and the running state is divided into kernel mode and user mode:

User mode: the user code does not have the ability to access the underlying resources directly, so it needs to rely on the system call API provided by the kernel. Under this isolation protection, even if the user program crashes, it will not affect the function of the whole system.

Kernel state: kernel code has maximum permissions and can execute arbitrary cpu instructions without any restrictions. The kernel state is usually run by the lowest and most reliable code provided by the operating system, and the code collapse in the kernel state is catastrophic, affecting the normal operation of the whole system.

2 you may be running a fake time

Does time have any other functions? Take a look at the help documentation

Root@chopin:~$ time-help-help: command not found real 0m0.129s user 0m0.084s sys 0m0.036s

Unexpectedly reported an error and took-- help as a command to execute, is that all time can do?

Well, I don't care anymore, just say the answer: you may be running a fake time. You may be a little confused, how come it's a fake.

In fact, on Linux systems, you may encounter three versions when using time:

# 1. Bash time is a shell keyword # 2. Zsh time is a reserved word # 3. GNU time time is / usr/bin/time

Our current Shell is Bash, and you can use the type command

Root@chopin:~$ type time time is a shell keyword

As you can see, the time we just executed is a built-in command for Shell. If you are using zsh, the default time is also the corresponding built-in command.

The GNU time command path is / usr/bin/time, which is included in most Linux distributions, and it is our pig's foot today.

3 more powerful featur

The GNU time command provides more powerful features:

More detailed statistics

Richer format output

Support for saving statistics to files

Let's learn how to write the use of GNU time.

1. The simplest use

Root@chopin:~$ / usr/bin/time sleep 2 0.00user 0.00system 0:02.00elapsed 0%CPU (0avgtext+0avgdata 1784maxresident) k 0inputs+0outputs (0major+72minor) pagefaults 0swaps

Using the GNU time command, just use the absolute path. We can see more output information, but the format is a little ugly. I'll talk about how to customize the format later.

two。 Maintain the output style of the built-in time

Some students will ask, can you output a format like built-in Shell? Yes, just use the-p option

Root@chopin:~$ / usr/bin/time-p sleep 2 real 2.00 user 0.00 sys 0.00

3. Output more detailed information

You can also output more detailed information, so that you can see the running information of the program at a glance. Please use the-v option

Root@chopin:~$ / usr/bin/time-v sleep 2 Command being timed: "sleep 2" User time (seconds): 0.00 System time (seconds): 0.00 Percent of CPU this job got: 0 Elapsed (wall clock) time (h:mm:ss or m:ss): 0pur02.00 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 1804 Average resident set Size (kbytes): 0 Major (requiring I File system inputs O) page faults: 0 Minor (reclaiming a frame) page faults: 71 Voluntary context switches: 1 Involuntary context switches: 1 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0

Here is a detailed description of the output indicators under the time command.

(1) time correlation

(2) memory related

(3) IO correlation

4. Statistics output to file

If you want to output time statistics to a file, you can use the-o option

Root@chopin:~$ / usr/bin/time-v-o a.txt sleep 2

The statistics are saved directly to a.txt. If you want the statistics to be appended to the file, you can add the-an option

5. Custom format output

If the built-in output format in the command does not meet your needs, GNU time can support a custom output format with various metric parameters through the option-f

/ usr/bin/time-f "real% e\ nuser% U\ nsys% S\ n" sleep 1 real 1.00 user 0.00 sys 0.00

The specific supported format, intimate Chopin has been sorted out for you.

These format parameters are too many, usually most cases can not be used, can be collected, so that later use can be quick reference.

The role of 4 in performance analysis

Seeing so many system parameters, it is inevitable that some students will wonder, what can these parameters do?

In fact, these indicators correspond to operating system cpu, memory, and IO. A deep understanding of these indicators can help you grasp the operation of the program in essence, and even help you analyze the performance bottlenecks of the program.

I would like to briefly explain a few concepts below, hoping to play a role in attracting jade.

(1) CPU time

Cpu time includes: real, user, sys. When user + sys > = real, the program is computationally intensive; when user + sys is much less than real, there is more IO waiting.

(2) context switching

The context usually refers to the running environment of the process, including the register value, memory stack and other information at that time. The kernel can fully recover an interrupted process task according to the context.

Context switching occurs when system calls and process switches are performed. When switching contexts, the operating system needs to save and recover context information for the process.

Context switching is divided into active and passive, active context switching shows that there are more blocking calls; passive context switching shows that the utilization rate of cpu is high.

When there are too many context switches, it means that more cpu time is spent on context switching, which greatly reduces the effective time of cpu processing process tasks.

(3) Page missing exception

There are many secondary page missing exceptions, which shows that the memory layout of the program is relatively reasonable and the hit rate is high; when there are many main missing page exceptions, it shows that the program has a large access to memory and a low hit rate.

The time to handle page fault exceptions and switch contexts is not included in user and sys, and when user + sys is found to be much less than real, most of the time is likely to be spent in these places, which need to be analyzed.

Thank you for your reading, the above is the content of "using Time statistics program running time on Linux". After the study of this article, I believe you have a deeper understanding of the problem of using Time statistics program running time on Linux, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.