Vuoi sapere quanto dura una procedura e molto altro? El Linux time Il comando restituisce le statistiche temporali, che ti fornisce informazioni interessanti sulle risorse utilizzate dai tuoi programmi.
il tempo ha molti parenti
Esistono molte distribuzioni Linux e diversi sistemi operativi simili a Unix. Ognuno di questi ha una shell di comando predefinita. La shell predefinita più comune sulle moderne distribuzioni Linux è la shell bash. Ma ce ne sono molti altri, come Z shell (zsh) y el shell Korn (ksh).
Tutti questi gusci incorporano i propri time comando, o come a Incorporato comando o come a parola riservata. Quando scrivi time in una finestra di terminale, la shell eseguirà il suo comando interno invece di usare GNU time binario fornito come parte della tua distribuzione Linux.
Vogliamo usare la versione GNU di time perché ha di più opzioni ed è più flessibile.
A che ora correrà?
Puoi verificare quale versione verrà eseguita utilizzando il type comando. type ti farà sapere se la shell gestirà le tue istruzioni da sola, con le loro routine interne, o li convertirà nel binario GNU.
in una finestra di terminale digita la parola type, uno spazio e poi la parola time e premi Invio.
digita ora
Possiamo vederlo nella shell bash time è una parola riservata. Ciò significa che Bash utilizzerà il suotime routine predefinite.
digita ora
Nel guscio Z (zsh) time è una parola riservata, quindi le routine interne della shell verranno utilizzate per impostazione predefinita.
digita ora
Nel guscio di Korn time è una parola chiave. Verrà utilizzata una routine interna al posto di GNU time comando.
IMPARENTATO: Che cos'è ZSH e perché dovrei usarlo al posto di Bash?
Esecuzione del comando GNU time
Se la shell del tuo sistema Linux ha un time la routine dovrà essere esplicita se vuoi usare GNU time binario. Dovresti:
- Fornisci il percorso completo al binario, Che cosa
/usr/bin/time. Corri ilwhich timecomando per trovare questo percorso. - Utilizzo
command time. - Usa una barra rovesciata come
time.
il which time Il comando ci dà il percorso del binario.
Possiamo testarlo usando /usr/bin/time come comando per avviare il binario GNU. Che funzioni. Abbiamo ricevuto una risposta da time comando che ci dice che non forniamo alcun parametro della riga di comando per farlo funzionare.
Digitando command time funziona anche, e otteniamo le stesse informazioni di utilizzo da time. il command comando dice alla shell di ignorare il seguente comando in modo che venga elaborato al di fuori della shell.
Usare un carattere prima del nome del comando è lo stesso di usare command prima del nome del comando.
Il modo più semplice per assicurarti di utilizzare GNU time binario è usare l'opzione barra rovesciata.
tempo
tempo
time invocare il guscio versione meteo. time utilizzare il time binario.
Uso del comando dell'ora
Misuriamo alcuni programmi. Stiamo usando due programmi chiamati loop1 e loop2. Sono stati creati da loop1.c e loop2.c. Non fanno nulla di utile se non dimostrare gli effetti di una sorta di inefficienza di codifica.
Questo è loop1.c. La lunghezza di una corda è necessaria all'interno dei due anelli annidati. La lunghezza si ottiene in anticipo, fuori dai due anelli annidati.
#includere "stdio.h"
#includere "string.h"
#includere "stdlib.h"
int main (int argomento, char* argv[])
{
int i, J, len, conteggio=0;
char szString[]="come-geek-come-geek-come-geek-come-geek-come-geek-come-geek";
// ottenere la lunghezza della stringa una volta, outside of loops
len = strlen( szString );
per (j=0; J<500000; j++) {
per (io=0; io < len; io++ ) {
Se (szString[io] == '-')
contare++;
}
}
printf("%d trattini contati", contare);
Uscita (0);
} // fine principale
Questo è loop2.c. La lunghezza della corda si ottiene più e più volte per ogni ciclo del loop esterno. Questa inefficienza dovrebbe riflettersi nei tempi.
#includere "stdio.h"
#includere "string.h"
#includere "stdlib.h"
int main (int argomento, char* argv[])
{
int i, J, conteggio=0;
char szString[]="come-geek-come-geek-come-geek-come-geek-come-geek-come-geek";
per (j=0; J<500000; j++) {
// ottenendo la lunghezza della stringa ogni
// time the loops trigger
for (io=0; io < strlen(szString); io++ ) {
Se (szString[io] == '-')
contare++;
}
}
printf("%d trattini contati", contare);
Uscita (0);
} // fine principale
Accendiamo il loop1 programar y utilizar time per misurare le loro prestazioni.
tempo ./loop1
Ora facciamo lo stesso per loop2.
tempo ./loop2
Questo ci ha dato due serie di risultati, ma sono in un formato davvero disgustoso. Possiamo fare qualcosa dopo., ma prendiamo alcune informazioni dai risultati.
Quando i programmi vengono eseguiti, ci sono due modalità di esecuzione tra le quali si alternano. Questi sono chiamati modalità utente e modo kernel.
Brevemente, una procedura in modalità utente non può accedere direttamente all'hardware o alla memoria di riferimento al di fuori della propria allocazione. Per accedere a queste risorse, la procedura deve fare richieste al kernel. Se il kernel approva la richiesta, la procedura viene eseguita in modalità kernel fino a quando il requisito non è soddisfatto. Prossimo, la procedura torna all'esecuzione in modalità utente.
I risultati per loop1 dicci che loop1 fare un passo 0,09 secondi in modalità utente. Il tempo trascorso in modalità kernel zero o il tempo in modalità kernel è troppo basso per essere registrato una volta arrotondato per difetto. Il tempo totale trascorso è stato 0,1 secondi. loop1 ricevuto una media di 89% Tempo CPU sul tempo totale trascorso.
L'inefficiente loop2 Il programma ha impiegato tre volte di più per essere eseguito. Il tuo tempo totale trascorso è 0,3 secondi. La durata del tempo di elaborazione in modalità utente è 0,29 secondi. Non viene registrato nulla per la modalità kernel. loop2 ricevuto una media di 96% Tempo CPU durante l'esecuzione.
Formatta l'output
Puoi personalizzare l'output da time utilizzando una stringa di formato. La stringa di formato può contenere testo e identificatori di formato. L'elenco degli identificatori di formato può essere trovato nella pagina man di time. Ciascuno degli identificatori di formato rappresenta un'informazione.
Quando la stringa viene stampata, gli identificatori di formato sono sostituiti dai valori effettivi che rappresentano. Come esempio, l'identificatore di formato per la percentuale di CPU è la lettera P . Per indicare a time che un identificatore di formato non è solo una lettera normale, aggiungi un segno di percentuale, Che cosa %P . Usiamolo in un esempio.
il -f L'opzione (stringa di formato) è usato per indicare time quello che segue è una stringa di formato.
La nostra stringa di formato stamperà i caratteri "Programma:”E il nome del programma (e qualsiasi parametro della riga di comando che passi al programma). il %C El identificatore di formato significa “Nome e argomenti della riga di comando del comando a tempo”. il n fa spostare l'output alla riga successiva.
Esistono molti identificatori di formato e fanno distinzione tra maiuscole e minuscole, quindi assicurati di inserirli correttamente quando lo fai da solo.
Prossimo, stamperemo i caratteri “Tempo totale:” seguito dal valore del tempo totale trascorso per questa esecuzione del programma (rappresentata da %E).
Noi usiamo n per dare un'altra nuova linea. Prossimo, stamperemo i caratteri “Maniera (S) di utente”, seguito dal valore del tempo della CPU trascorso in modalità utente, rappresentato dal %U.
Noi usiamo n per dare un'altra nuova linea. Questa volta ci stiamo preparando per il valore dell'ora del kernel. Stampiamo i caratteri “Modalità kernel (S)”, seguito dall'identificatore di formato per il tempo della CPU trascorso in modalità kernel, Che cos'è %S.
Finalmente, stampiamo i caratteri “nprocessore: "Per darci una nuova riga e un titolo per questo valore di dati. il %P L'identificatore di formato fornirà la percentuale media del tempo CPU utilizzato dalla procedura a tempo.
L'intera stringa di formato è tra virgolette. Avremmo potuto includerne qualcuna t caratteri per inserire tabulazioni nell'output se siamo esigenti nell'allineare i valori.
tempo -f "Programma: %CnTempo totale: %EnUser Mode (S) %Modalità Unkernel (S) %SnCPU: %P" ./ciclo1
Invia l'output a un file
Per tenere traccia dei tempi dei test che hai eseguito, puoi inviare l'output da time in un file. Per fare questo usa il -o (Uscita) opzione. L'output del tuo programma continuerà a essere visualizzato nella finestra del terminale. È solo l'uscita da time che viene reindirizzato al file.
Possiamo rieseguire il test e salvare l'output in test_results.txt file come segue:
tempo -o risultati_prova.txt -f "Programma: %CnTempo totale: %EnUser Mode (S) %Modalità Unkernel (S) %SnCPU: %P" ./ciclo1
cat test_results.txt
il loop1 L'output del programma viene visualizzato nella finestra del terminale e i risultati di time Vai al test_results.txt procedimento.
Se vuoi catturare il prossimo set di risultati nello stesso file, deve usare il -a (Aggiungere) opzione strada successiva:
tempo -o risultati_prova.txt -a -f "Programma: %CnTempo totale: %EnUser Mode (S) %Modalità Unkernel (S) %SnCPU: %P" ./ciclo2
cat test_results.txt
Dovrebbe ora essere chiaro perché usiamo il %C identificatore di formato per includere il nome del programma nell'output della stringa di formato.
E siamo fuori tempo massimo
Probabilmente più utile per programmatori e sviluppatori per modificare il loro codice, il time Il comando è utile anche per chiunque voglia scoprire qualcosa in più su cosa succede sotto il cofano ogni volta che avvia un programma..
