12.5 Profilare i propri programmi awk

È possibile tener traccia dell’esecuzione dei propri programmi awk. Ciò si può fare passando l’opzione --profile a gawk. Al termine dell’esecuzione, gawk crea un profilo del programma in un file chiamato awkprof.out. A causa dell’attività di profilazione l’esecuzione del programma è più lenta fino al 45% rispetto al normale.

Come mostrato nel seguente esempio, l’opzione --profile può essere usata per cambiare il nome del file su cui gawk scriverà il profilo:

gawk --profile=mioprog.prof -f mioprog.awk dati1 dati2

Nell’esempio precedente, gawk mette il profilo in mioprog.prof anziché in awkprof.out.

Vediamo ora una sessione d’esempio che mostra un semplice programma awk, i suoi dati in input, e il risultato dell’esecuzione di gawk con l’opzione --profile. Innanzitutto, il programma awk:

BEGIN { print "Prima regola BEGIN" }

END { print "Prima regola END" }

/pippo/ {
    print "trovato /pippo/, perbacco"
    for (i = 1; i <= 3; i++)
        sing()
}

{
    if (/pippo/)
        print "l'if è vero"
    else
        print "l'else è vero"
}

BEGIN { print "Seconda regola BEGIN" }

END { print "Seconda regola END" }

function sing(    ignora)
{
    print "Devo essere io!"
}

Questi sono i dati in input:

pippo
pluto
paperino
pippo
cianfrusaglie

E questo è il file awkprof.out che è il risultato dell’esecuzione del profilatore di gawk su questo programma e sui dati (quest’esempio dimostra anche che i programmatori di awk a volte si alzano molto presto al mattino per lavorare):

    # profilo gawk, creato Mon Sep 29 05:16:21 2014

    # BEGIN regola(e)

    BEGIN {
 1  	print "Prima regola BEGIN"
    }

    BEGIN {
 1  	print "Seconda regola BEGIN"
    }

    # Regola(e)

 5  /pippo/ { # 2
 2  	print "trovato /pippo/, perbacco"
 6  	for (i = 1; i <= 3; i++) {
 6  		sing()
    	}
    }

 5  {
 5  	if (/pippo/) { # 2
 2  		print "l'if è vero"
 3  	} else {
 3  		print "l'else è vero"
    	}
    }

    # END regola(e)

    END {
 1  	print "Prima regola END"
    }

    END {
 1  	print "Seconda regola END"
    }


    # Funzioni, in ordine alfabetico

 6  function sing(ignora)
    {
 6  	print "Devo essere io!"
    }

Quest’esempio illustra molte caratteristiche fondamentali dell’output della profilazione. Queste sono:

• Il programma viene stampato nell’ordine: regole BEGIN, regole BEGINFILE, regole criterio di ricerca–azione, regole ENDFILE, regole END, e funzioni, elencate in ordine alfabetico. Le regole BEGIN ed END multiple conservano le loro distinte identità, così come le regole BEGINFILE ed ENDFILE multiple.
• Le regole criterio di ricerca–azione hanno due conteggi. Il primo conteggio, a sinistra della regola, mostra quante volte il criterio di ricerca della regola è stato testato. Il secondo conteggio, alla destra della parentesi graffa aperta, all’interno di un commento, mostra quante volte l’azione della regola è stata eseguita. La differenza tra i due indica quante volte il criterio di ricerca della regola è stato valutato come falso.
• Analogamente, il conteggio per un’istruzione if-else mostra quante volte la condizione è stata testata. Alla destra della parentesi graffa sinistra aperta per il corpo di if c’è un conteggio che mostra quante volte la condizione è stata trovata vera. Il conteggio per else indica quante volte la verifica non ha avuto successo.
• Il conteggio per un ciclo (come for o while) mostra quante volte il test del ciclo è stato eseguito. (Per questo motivo, non si può solamente guardare il conteggio sulla prima istruzione in una regola per determinare quante volte la regola è stata eseguita. Se la prima istruzione è un ciclo, il conteggio è ingannevole.)
• Per le funzioni definite dall’utente, il conteggio vicino alla parola chiave function indica quante volte la funzione è stata chiamata. I conteggi vicino alle istruzioni nel corpo mostrano quante volte quelle istruzioni sono state eseguite.
• L’impaginazione usa lo stile “K&R” con le tabulazioni. Le parentesi graffe sono usate dappertutto, anche dove il corpo di un if, di un else o di un ciclo è formato da un’unica istruzione.
• Le parentesi vengono usate solo dov’è necessario, come si rileva dalla struttura del programma e dalle regole di precedenza. Per esempio, ‘(3 + 5) * 4’ significa sommare tre e cinque, quindi moltiplicare il totale per quattro. Di contro, ‘3 + 5 * 4’ non ha parentesi, e significa ‘3 + (5 * 4)’. Tuttavia, le parentesi inserite esplicitamente nel programma sorgente sono conservate come sono state scritte.
• Le parentesi vengono usate attorno agli argomenti di print e printf solo quando l’istruzione print o printf è seguita da una ridirezione. Similarmente, se l’oggetto di una ridirezione non è uno scalare, viene messo tra parentesi.
• gawk mette dei commenti iniziali davanti alle regole BEGIN ed END, alle regole BEGINFILE ed ENDFILE, alle regole criterio_di_ricerca–azione e alle funzioni.

La versione profilata del proprio programma potrebbe non apparire esattamente come quella scritta durante la stesura del programma. Questo perché gawk crea la versione profilata facendo una “stampa elegante” della sua rappresentazione interna del programma. Un vantaggio di ciò è che gawk può produrre una rappresentazione standard. Inoltre, cose come:

/pippo/

appaiono come:

/pippo/   {
    print
}

che è corretto, ma probabilmente inatteso. (Se un programma usa sia ‘print $0’ che un semplice ‘print’, tale differenza è mantenuta.)

Oltre a creare profili una volta completato il programma, gawk può generare un profilo mentre è in esecuzione. Questo è utile se il proprio programma awk entra in un ciclo infinito e si vuol vedere cosa è stato eseguito. Per usare questa funzionalità, bisogna eseguire gawk con l’opzione --profile in background:

$ gawk --profile -f mioprog &
[1] 13992

La shell stampa un numero di job e il numero di ID del relativo processo; in questo caso, 13992. Si usi il comando kill per inviare il segnale USR1 a gawk:

$ kill -USR1 13992

Come al solito, la versione profilata del programma è scritta nel file awkprof.out, o in un file differente se ne viene specificato uno con l’opzione --profile.

Assieme al profilo regolare, come mostrato in precedenza, il file del profilo include una traccia di ogni funzione attiva:

# `Stack' (Pila) Chiamate Funzione:

#   3. paperino
#   2. pluto
#   1. pippo
# -- main --

Si può inviare a gawk il segnale USR1 quante volte si vuole. Ogni volta, il profilo e la traccia della chiamata alla funzione vengono aggiunte in fondo al file di profilo creato.

Se si usa il segnale HUP invece del segnale USR1, gawk genera il profilo e la traccia della chiamata alla funzione ed esce.

Quando gawk viene eseguito sui sistemi MS-Windows, usa i segnali INT e QUIT per generare il profilo, e nel caso del segnale INT, gawk esce. Questo perché questi sistemi non prevedono il comando kill, per cui gli unici segnali che si possono trasmettere a un programma sono quelli generati dalla tastiera. Il segnale INT è generato dalle combinazioni di tasti Ctrl-c o Ctrl-BREAK, mentre il segnale QUIT è generato dalla combinazione di tasti Ctrl-\.

Infine, gawk accetta anche un’altra opzione, --pretty-print. Quando viene chiamato in questo modo, gawk fa una “stampa elegante” del programma nel file awkprof.out, senza conteggi sull’esecuzione.

NOTA: Una volta, l’opzione --pretty-print eseguiva anche il programma. Ora non più.

C’è una differenza significativa tra l’output creato durante la profilazione, e quello creato durante la stampa elegante. L’output della stampa elegante preserva i commenti originali che erano nel programma, anche se la loro posizione può non corrispondere esattamente alle posizioni originali che avevano nel codice sorgente. Tuttavia, nessun commento dovrebbe andare perso. Inoltre, gawk fa del suo meglio per mantenere la distinzione tra commenti posti dopo delle istruzioni e commenti su righe a sé stanti. Tuttavia, non sempre questo può avvenire in maniera perfetta.

Comunque, per una precisa scelta progettuale, l’output della profilazione omette i commenti del programma originale. Questo permette di concentrarsi sui dati del conteggio di esecuzione ed evita la tentazione di usare il profilatore per creare una stampa elegante.

Oltre a ciò, l’output stampato in modo elegante non ha l’indentazione iniziale che ha l’output della profilazione. Questo rende agevole la stampa elegante del proprio codice una volta completato lo sviluppo, usando poi il risultato come versione finale del programma.

Poiché la rappresentazione interna del programma è formattata per essere aderente al programma awk in questione, la profilazione e la stampa elegante (opzione --pretty-print) disabilitano automaticamente le optimizzazioni di default di gawk.

La profilazione e la stampa elegante mantengono anche il formato originale delle costanti numeriche; se sono stati usati dei valori ottali o esadecimali nel codice sorgente, questi compariranno nell’output nello stesso formato con cui sono stati inseriti.