☰

Por que o tempo real pode ser menor que o tempo do usuário

tag-icon • tag-icon time
Por que o tempo real pode ser menor que o tempo do usuário

Eu tenho um script que converte arquivos de vídeo e o executo no servidor em dados de teste e meço seu tempo em time. Como resultado eu vi:

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

Por que o tempo real é muito menor que o tempo do usuário? Isso tem alguma conexão com multithreading? Ou o que mais?

Editar:E acho que esse script estava rodando por volta de 2m48s

Responder1

A saída que você mostra é um pouco estranha, já que o tempo real normalmente seria maior que os outros dois.

  • Reala hora é a hora do relógio de parede. (o que poderíamos medir com um cronômetro)
  • Usertempo é a quantidade de tempo gasto no modo de usuário dentro do processo
  • Sysé o tempo de CPU gasto no kernel dentro do processo.

Então, suponho que se o trabalho fosse feito por vários processadores simultaneamente, o tempo de CPU seria maior que o tempo decorrido do relógio de parede.

Este era um tipo de aplicativo simultâneo/multithread/paralelo?

Apenas como exemplo, é isso que recebo no meu sistema Linux quando emito o time find .comando. Como esperado, o realtempo decorrido é muito maior do que os outros neste processo de usuário único/núcleo único.

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

A regra prática é:

  • real <usuário: o processo é vinculado à CPU e aproveita a execução paralela em vários núcleos/CPUs.
  • usuário real ≈: O processo é limitado pela CPU e não tira vantagem da execução paralela.
  • real> usuário: o processo está vinculado à E/S. A execução em múltiplos núcleos teria pouca ou nenhuma vantagem.

Responder2

Só para ilustrar o que foi dito, com dois processos encadeados fazendo alguns cálculos.

/*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 */

compilar

gcc a.c -lpthread

(Isso é apenas para ilustrar, na vida real eu deveria ter adicionado a flag -D_REENTRANT)

$ time ./a.out

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

(Os tempos estão em um Intel Atom que possui dois núcleos lentos :))

Responder3

Não precisa ser programa(s) multithread; você pode obter o mesmo efeito com vários processos. Eu escrevi um programa C para fazer alguns cálculos triviais de números:

$ time ./runner

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

Então escrevi um script para executar duas cópias do processo:

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

$ time ./run_script

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

Responder4

Como disse Levon:

Eu tenho um i7 (8 processadores), então se rodar em bash:

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

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

Então, se restringir o bash a um processo comtaskset -cp 0 $BASHPID

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

agora o resultado é

$ 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

informação relacionada