Como usar o comando time no Linux

Quer saber quanto tempo um processo é executado e muito mais? O comando de tempo do Linux retorna estatísticas de tempo, fornecendo informações interessantes sobre os recursos usados ​​por seus programas.

Tem muitos parentes

Existem muitas distribuições Linux e diferentes sistemas operacionais parecidos com Unix. Cada um deles tem um shell de comando padrão. O shell padrão mais comum nas distribuições modernas do Linux é o shell bash. Mas há muitos outros, como o shell Z (zsh) e o shell Korn (ksh).

Todos esses shells incorporam seu próprio comando time, seja como um comando interno ou como um comando reservado. palavra. Quando você digita o tempo em uma janela de terminal, o shell executará seu comando interno em vez de usar o binário de tempo GNU que é fornecido como parte de sua distribuição Linux.

Queremos usar a versão GNU do tempo porque tem mais opções e é mais flexível.

Qual será o tempo de execução?

Você pode verificar qual versão será executada usando o comando type. type informará se o shell manipulará sua própria instrução, com suas rotinas internas, ou passará para o binário GNU.

em uma janela de terminal, digite o tipo de palavra, um espaço e, em seguida, o tempo da palavra e pressione Enter.

 digite o tempo 

Podemos ver que no tempo do shell bash é uma palavra reservada. Isso significa que o Bash usará suas rotinas de horário interno por padrão.

 digite o tempo 

No shell Z (zsh) o tempo é uma palavra reservada , então as rotinas internas do shell serão usadas por padrão.

 tipo time 

No tempo do shell Korn é uma palavra-chave. Uma rotina interna será usada ao invés do comando GNU time.

RELACIONADO: O que é ZSH e por que você deve usá-lo em vez de Bash?

Executando o comando GNU time

Se o shell em seu sistema Linux tiver uma rotina de tempo interna, você precisará ser explícito se desejar usar o binário de tempo do GNU. Você deve:

• Fornecer todo o caminho para o binário, como / usr / bin / time. Execute o comando which time para encontrar esse caminho.
• Use o tempo de comando.
• Use uma barra invertida como \ time.

O comando which time nos dá o caminho para o binário.

Podemos testar isso usando / usr / bin / time como um comando para iniciar o binário GNU. Isso funciona. Recebemos uma resposta do comando de tempo nos dizendo que não fornecemos nenhum parâmetro de linha de comando para ele funcionar.

O tempo de comando de digitação também funciona e obtemos as mesmas informações de uso a partir do momento. O comando command diz ao shell para ignorar o próximo comando para que ele seja processado fora do shell.

Usar um caractere \ antes do nome do comando é o mesmo que usar o comando antes do nome do comando.

A maneira mais simples de garantir que você está usando o binário de tempo GNU é usar a opção de barra invertida.

 tempo 

 \ tempo [/ PRE ] 
 
 
 invoca a versão do tempo do shell. \ time usa o timebinary.  
 Usando o comando time 
 
 Vamos marcar alguns programas. Estamos usando dois programas chamados loop1 e loop2. Eles foram criados a partir de loop1.c e loop2.c. Eles não fazem nada útil além de demonstrar os efeitos de um tipo de ineficiência de codificação.  
 Isso é loop1.c. O comprimento de uma string é necessário nos dois loops aninhados. O comprimento é obtido antecipadamente, fora dos dois loops aninhados.  
 
 #include "stdio.h" #include "string.h" #include "stdlib.h" int main (int argc , char * argv []) {int i, j, len, contagem = 0; char szString [] = "como-geek-how-to-geek-how-to-geek-how-to-nerd-how-to-nerd-how-to-geek"; // obtém o comprimento da string uma vez, fora dos loops len = strlen (szString); para (j = 0; j < 500000; j ++) {para (i = 0; i < len; i ++) {if (szString [i] == '-') contagem ++; }} printf ("Contados% d hífens \ n", contagem); saída (0); } // fim do main 
 
 Isso é loop2.c. O comprimento da string é obtido hora após hora para cada ciclo do loop externo. Essa ineficiência deve aparecer nos timings.  
 
 #include "stdio.h" #include "string.h" #include "stdlib.h" int main (int argc, char * argv []) {int i, j, contagem = 0; char szString [] = "como-geek-how-to-geek-how-to-geek-how-to-nerd-how-to-nerd-how-to-geek"; para (j = 0; j < 500000; j ++) {// obtendo o comprimento da cadeia a cada // hora que os loops são acionados para (i = 0; i < strlen (szString); i ++) {if (szString [i] = = '-') count ++; }} printf ("Contados% d hífens \ n", contagem); saída (0); } // fim do main 
 Vamos iniciar o programa loop1 e usar o tempo para medir seu desempenho.  
 
 \ hora ./loop1
 
 Agora vamos fazer o mesmo para loop2.  
 
 \ hora ./loop2
 
 Isso nos dá dois conjuntos de resultados, mas eles estão realmente formato feio. Nós podemos fazer algo sobre isso mais tarde, mas vamos pegar alguns bits de informação dos resultados.  
 Quando os programas rodam, há dois modos de execução que são alternados entre eles. Estes são chamados de modo de usuário e modo de kernel.  
 Em poucas palavras, um processo no modo de usuário não pode acessar diretamente hardware ou memória de referência fora de sua própria alocação. Para obter acesso a esses recursos, o processo deve fazer solicitações ao kernel. Se o kernel aprovar o pedido, o processo entra na execução do modo kernel até que o requisito seja satisfeito. O processo é então alterado para a execução no modo de usuário.  
 Os resultados para loop1 nos dizem que o loop1 gastou 0,09 segundos no modo de usuário. Ele passou o tempo zero no modo kernel ou o tempo no modo kernel é um valor muito baixo para registrar uma vez que tenha sido arredondado para baixo. O tempo total decorrido foi de 0,1 segundos. loop1 recebeu uma média de 89% do tempo de CPU durante o tempo total decorrido.  
 O programa loop2 ineficiente levou três vezes mais tempo para ser executado. Seu tempo total decorrido é de 0,3 segundos. A duração do tempo de processamento no modo de usuário é de 0,29 segundos. Nada está se registrando no modo kernel. loop2 recebeu uma média de 96% do tempo de CPU pela duração de sua execução.  
 Formatando a saída 
 
 Você pode personalizar a saída de hora usando uma string de formato. A string de formatação pode conter especificadores de texto e formato. A lista de especificadores de formato pode ser encontrada na página do manual por tempo. Cada um dos especificadores de formato representa uma informação.  
 Quando a cadeia é impressa, os especificadores de formato são substituídos pelos valores reais que representam. Por exemplo, o especificador de formato para a porcentagem de CPU é a letra P. Para indicar a hora em que um especificador de formato não é apenas uma letra normal, adicione um sinal de porcentagem a ele, como% P. Vamos usá-lo em um exemplo.  
 A opção -f (string de formato) é usada para informar que o que segue é uma string de formatação.  
 Nossa string de formatação vai imprimir a caracteres “Program:” e o nome do programa (e qualquer parâmetro de linha de comando que você passar para o programa). O especificador de formato% C significa “Argumentos de nome e linha de comando do comando sendo cronometrado”. O \ n faz com que a saída se mova para a próxima linha.  
 Existem muitos especificadores de formatos e eles diferenciam maiúsculas e minúsculas, portanto, certifique-se de estar inserindo-os corretamente quando fizer isso por si mesmos.  
 Em seguida, vamos imprimir os caracteres “Total time:” seguido pelo valor do tempo total decorrido para esta execução do programa (representado por% E).  
 Usamos \ n para dar outra nova linha. Em seguida, imprimiremos os caracteres "User Mode (s)", seguidos pelo valor do tempo de CPU gasto no modo de usuário, representado pelo% U.  
 Usamos \ n para fornecer outra nova linha . Desta vez estamos nos preparando para o valor do tempo do kernel. Nós imprimimos os caracteres “Kernel Mode (s)“, seguidos pelo especificador de formato para o tempo de CPU gasto no modo kernel, que é% S.  
 Finalmente, vamos imprimir os caracteres “\ nCPU: ”Para nos dar uma nova linha e o título para este valor de dados. O especificador de formato% P fornecerá a porcentagem média do tempo de CPU usado pelo processo cronometrado.  
 A string de formatação inteira é colocada entre aspas. Poderíamos ter incluído alguns caracteres para colocar tabulações na saída se fôssemos muito exigentes quanto ao alinhamento dos valores.  
 
 \ tempo -f "Programa:% C \ nTempo total:% E \ nUsuário (s) de usuário% U \ nOs modos de kernel% S \ nCPU:% P "./loop1
 
 Enviando a saída para um arquivo 
 
 Para manter um registro dos tempos dos testes realizados, você pode enviar a saída de um tempo para um arquivo. Para fazer isso, use a opção -o (output). A saída do seu programa ainda será exibida na janela do terminal. É apenas a saída do tempo que é redirecionada para o arquivo.  
 Podemos executar novamente o teste e salvar a saída no arquivo test_results.txt da seguinte forma:  
 
 \ time -o teste_resultados.txt -f "Programa:% C \ nTempo total:% E \ nSomodo (s) de usuário% U \ nModo (s) de kernel% S \ nCPU:% P" ./loop1
 
 
 cat test_results.txt 
 
 
 A saída do programa loop1 é exibida na janela do terminal e os resultados do tempo vão para o arquivo test_results.txt.  
 Se você deseja capturar o próximo conjunto de resulta no mesmo arquivo, você deve usar a opção -a (append) da seguinte forma:  
 
 \ time -o teste_resultados.txt -a -f "Programa:% C \ nTempo total:% \ NUsmodo (s) de usuário% U \ nModo (s) de kernel% S \ nCPU:% P "./loop2
[REC #cat test_results.txt 

Agora deve estar claro por que usamos o especificador de formato% C para incluir o nome do programa na saída da string de formato.

E estamos sem tempo

]

Provavelmente mais útil para programadores e desenvolvedores para afinar seu código, o comando de tempo também é útil para qualquer pessoa que queira descobrir um pouco mais sobre o que acontece sob o capô toda vez que você iniciar um programa.

Via: How to Geek