Quer saber por quanto tempo um processo é executado e muito mais? O comando de tempo do Linux retorna estatísticas de tempo, dando a você uma visão interessante dos recursos usados por seus programas.
o tempo tem muitos parentes
Existem muitas distribuições de Linux e diferentes sistemas operacionais do tipo Unix. Cada um deles possui um shell de comando padrão. O shell padrão mais comum nas distribuições Linux modernas é o shell bash. Mas existem muitos outros, como o shell Z (zsh) e o shell Korn (ksh).
Todos esses shells incorporam seu próprio comando de tempo, seja como um construídas em comando ou como um palavra reservada. Quando você digita hora em uma janela de terminal, o shell executa 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.
Que horas será executado?
Você pode verificar qual versão será executada usando o comando type. type permitirá que você saiba se o próprio shell irá lidar com sua instrução, com suas rotinas internas, ou passá-la para o binário GNU.
em uma janela de terminal, digite o tipo de palavra, um espaço e, em seguida, a palavra hora e pressione Enter.
type time
Podemos ver que no shell bash, o tempo é uma palavra reservada. Isso significa que o Bash usará suas rotinas de tempo interno por padrão.
type time
No shell Z (zsh), o tempo é uma palavra reservada, portanto, as rotinas internas do shell serão usadas por padrão.
type time
No shell Korn, o tempo é uma palavra-chave. Uma rotina interna será usada em vez do comando GNU time.
Executando o comando GNU time
Se o shell em seu sistema Linux tem uma rotina de tempo interna, você precisará ser explícito se quiser usar o binário de tempo GNU. Você deve:
Fornece o caminho completo para o binário, como / usr / bin / time. Execute o comando which time para encontrar este caminho.
Use o tempo de comando.
Use uma barra invertida como o tempo.
O comando which time fornece 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 time informando que não fornecemos nenhum parâmetro de linha de comando para que ele funcione.
O tempo de comando de digitação também funciona, e obtemos as mesmas informações de uso com o tempo. O comando comando diz ao shell para ignorar o próximo comando para que seja processado fora do shell.
Usar um caractere antes do nome do comando é o mesmo que usar command 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.
time
time
time invoca a versão shell de time. o tempo usa o binário do tempo.
Usando o comando de tempo
Vamos cronometrar alguns programas. Estamos usando dois programas chamados loop1 e loop2. Eles foram criados a partir de loop1.ce loop2.c. Eles não fazem nada de útil além de demonstrar os efeitos de um tipo de ineficiência de codificação.
Este é o loop1.c. O comprimento de uma string é necessário dentro dos 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, count=0;
char szString[]="how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek";
// get length of string once, outside of loops
len = strlen( szString );
for (j=0; j
This is loop2.c. The length of the string is obtained time after time for every cycle of the outer loop. This inefficiency ought to show up in the timings.
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
int main (int argc, char* argv[])
{
int i, j, count=0;
char szString[]="how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek-how-to-geek";
for (j=0; j
Let’s fire up the loop1 program and use time to measure its performance.
time ./loop1
Agora vamos fazer o mesmo para o loop2.
time ./loop2
Isso nos deu dois conjuntos de resultados, mas eles estão em um formato muito feio. Podemos fazer algo sobre isso mais tarde, mas vamos escolher algumas informações dos resultados.
Quando os programas são executados, há dois modos de execução entre os quais eles são alternados. Eles são chamados de modo de usuário e modo de kernel.
Resumidamente, um processo no modo de usuário não pode acessar diretamente o hardware ou a memória de referência fora de sua própria alocação. Para obter acesso a tais recursos, o processo deve fazer solicitações ao kernel. Se o kernel aprovar a solicitação, o processo entra em execução no modo kernel até que o requisito seja atendido. O processo é então alternado de volta para a execução no modo de usuário.
Os resultados para loop1 nos dizem que loop1 gastou 0,09 segundos no modo de usuário. Ele gastou tempo zero no modo kernel ou o tempo no modo kernel é um valor muito baixo para registrar uma vez que foi arredondado para baixo. O tempo total decorrido foi de 0,1 segundos. O loop1 obteve uma média de 89% do tempo de CPU sobre a duração de seu 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á sendo registrado para o modo kernel. O loop2 recebeu uma média de 96% do tempo de CPU para a duração de sua execução.
Formatando a saída
Você pode personalizar a saída de tempo usando uma string de formato. A string de formato pode conter especificadores de texto e formato. A lista de especificadores de formato pode ser encontrado na página de manual por tempo. Cada um dos especificadores de formato representa uma informação.
Quando a string é 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 ao tempo que um especificador de formato não é apenas uma letra regular, 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 a hora que o que se segue é uma string de formato.
Nossa string de formato irá imprimir os caracteres “Programa:” e o nome do programa (e quaisquer parâmetros de linha de comando que você passar para o programa). O especificador de formato% C significa “Nome e argumentos de linha de comando do comando sendo cronometrado”. O n faz com que a saída mova para a próxima linha.
Existem muitos especificadores de formato e eles diferenciam maiúsculas de minúsculas, portanto, certifique-se de inseri-los corretamente ao fazer isso.
A seguir imprimiremos os caracteres “Tempo total:” seguidos do valor do tempo total decorrido para esta execução do programa (representado por% E).
Usamos n para fornecer outra nova linha. Em seguida, imprimiremos os caracteres “Modo (s) de usuário“, seguidos do 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 de tempo do kernel. Imprimimos os caracteres “Kernel Mode (s)“, seguidos do 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 de tempo de CPU usado pelo processo cronometrado.
Toda a string de formato é colocada entre aspas. Poderíamos ter incluído alguns caracteres t para colocar tabulações na saída se estivéssemos preocupados com o alinhamento dos valores.
time -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop1
Enviando a saída para um arquivo
Para manter um registro das temporizações dos testes realizados, você pode enviar a saída de tempos para um arquivo. Para fazer isso, use a opção -o (saída). 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 o teste novamente e salvar a saída no arquivo test_results.txt da seguinte maneira:
time -o test_results.txt -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop1
cat test_results.txt
A saída do programa loop1 é exibida na janela do terminal e os resultados vão para o arquivo test_results.txt.
Se quiser capturar o próximo conjunto de resultados no mesmo arquivo, você deve usar a opção -a (anexar) da seguinte maneira:
time -o test_results.txt -a -f "Program: %CnTotal time: %EnUser Mode (s) %UnKernel Mode (s) %SnCPU: %P" ./loop2
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 ajustar seu código, o comando time também é útil para quem deseja descobrir um pouco mais sobre o que acontece nos bastidores cada vez que você inicia um programa.
