Why real time can be lower than user time

Question

I have a script converting video files and I run it at server on test data and measure its time by time. In result I saw:

real    2m48.326s
user    6m57.498s
sys     0m3.120s

Why real time is that much lower than user time? Does this have any connection with multithreading? Or what else?

Edit: And I think that script was running circa 2m48s

Answer 1

The output you show is a bit odd, since real time would usually be bigger than the other two.

• Real time is wall clock time. (what we could measure with a stopwatch)
• User time is the amount of time spend in user-mode within the process
• Sys is the CPU time spend in the kernel within the process.

So I suppose if the work was done by several processors concurrently, the CPU time would be higher than the elapsed wall clock time.

Was this a concurrent/multi-threaded/parallel type of application?

Just as an example, this is what I get on my Linux system when I issue the time find . command. As expected the elapsed real time is much larger than the others on this single user/single core process.

real    0m5.231s
user    0m0.072s
sys     0m0.088s

The rule of thumb is:

• real < user: The process is CPU bound and takes advantage of parallel execution on multiple cores/CPUs.
• real ≈ user: The process is CPU bound and takes no advantage of parallel exeuction.
• real > user: The process is I/O bound. Execution on multiple cores would be of little to no advantage.

Answer 2

Just to illustrate what has been said, with a two threaded processes doing some calculation.

/*a.c/*
    #include <pthread.h>
    static void  * dosomething () {
        unsigned long a,b=1;
        for (a=1000000000; a>0; a--) b*=3;
        return NULL;
    }
    main () {
        pthread_t one, two;
        pthread_create(&one,NULL, dosomething, NULL);
        pthread_create(&two,NULL, dosomething, NULL);
        pthread_join (one, NULL);
        pthread_join (two, NULL);
    }
/* end of a.c */

compile

gcc a.c -lpthread

(This is just to illustrate, in real life I should have added the -D_REENTRANT flag)

$ time ./a.out

real    0m7.415s
user    0m13.105s
sys     0m0.032s

(Times are on an Intel Atom that has two slow cores :) )

Answer 3

It doesn’t need to be multi-threaded program(s); you can get the same effect with multiple processes.  I wrote a C program to do some trivial number crunching:

$ time ./runner

real    1m12.746s
user    1m12.493s
sys     0m0.015s

Then I wrote a script to run two copies of the process:

$ cat run_script
#!/bin/sh
./runner &
./runner &
wait

$ time ./run_script

real    1m31.231s
user    3m0.538s
sys     0m0.215s

Answer 4

As Levon said:

I have a i7 (8 processors), so if run in bash:

$ time for ((i=0;i<1000000;i++)); do echo $i; done | wc -l
1000000

real    0m4,878s
user    0m4,368s
sys     0m3,083s

Then if restrict bash to one processos with taskset -cp 0 $BASHPID

$ taskset -cp 0 $BASHPID                                                                                         
pid 30551's current affinity list: 0-7
pid 30551's new affinity list: 0

now the result is

$ time for ((i=0;i<1000000;i++)); do echo $i; done | wc -l
1000000

real    0m7,120s
user    0m4,282s
sys     0m2,824s

https://www.looklinux.com/how-to-run-process-or-program-on-specific-cpu-cores-in-linux/

http://man7.org/linux/man-pages/man1/time.1.html