Zweifellos ist das Testen ein integraler Bestandteil und einer der wichtigsten Aspekte des Softwareentwicklungsprozesses. Und mit Testen meinen wir nicht nur das Testen des Codes auf Fehler - natürlich ist die Fehlererkennung wichtig, da niemand möchte, dass seine Software fehlerhaft ist - die Leistung des Codes ist heutzutage ebenso wichtig.
Bis ins letzte Bit aufgeschlüsselt, testen Leistungstests effektiv, wie viel Zeit ein bestimmtes Stück Code – sagen wir eine Funktion – verbraucht. Wie üblich kann eine Funktion oder eine Gruppe von Funktionen einem der vielen Merkmale einer Software entsprechen. Wenn wir also durch Leistungstests die Leistung dieser Funktionen im Code verbessern können, wird die Gesamtleistung der Software besser.
Wenn Sie ein Programmierer sind, der Code in der Programmiersprache C, Pascal oder Fortran77 schreibt und Linux als Entwicklungsplattform verwendet, werden Sie froh sein zu wissen, dass es ein leistungsstarkes Tool gibt, mit dem Sie die Leistung Ihres Codes überprüfen können - Das fragliche Tool ist Gprof. In diesem Tutorial besprechen wir die Details, wie Sie dieses Tool herunterladen, installieren und verwenden können.
Bevor wir fortfahren, beachten Sie bitte, dass alle in diesem Tutorial erwähnten Beispiele und Anweisungen auf Ubuntu 14.04LTS getestet wurden und die verwendete Gprof-Version 2.24 ist.
Was ist Gprof?
Also, was genau ist Gprof? Laut der offiziellen Dokumentation des Tools gibt es Benutzern ein Ausführungsprofil ihrer C-, Pascal- oder Fortran77-Programme. Was Gprof im Grunde tut, ist, es berechnet die Zeit, die in jeder Routine oder Funktion verbracht wird. "Als nächstes werden diese Zeiten entlang der Kanten des Anrufgraphen propagiert. Zyklen werden entdeckt und Aufrufe in einen Zyklus werden gemacht, um die Zeit des Zyklus zu teilen."
Wenn das alles an dieser Stelle etwas verwirrend klingt (insbesondere der Teil in Anführungszeichen), machen Sie sich keine Sorgen, wir werden die Dinge anhand eines Beispiels verdeutlichen. Also, lies weiter.
Gprof herunterladen und installieren
Prüfen Sie zunächst, ob das Tool bereits auf Ihrem System installiert ist. Führen Sie dazu einfach den folgenden Befehl in einem Terminal aus.
$gprof
Wenn Sie eine Fehlermeldung erhalten wie:
$ a.out:Keine solche Datei oder Verzeichnis
dann würde dies bedeuten, dass das Tool bereits installiert ist. Andernfalls können Sie es mit dem folgenden Befehl installieren:
$ apt-get install binutils
Gprof-Nutzung
Natürlich ist der beste Weg, ein Tool wie Gprof zu verstehen, ein praktisches Beispiel. Wir beginnen also mit einem C-Sprachprogramm, das wir über Gprof profilieren werden. Hier ist das Programm:
//test_gprof.c
#include
void func4(void)
{
printf("\n Inside func4() \n");
for(int count=0;count<=0XFFFF;count++);
}
void func3(void)
{
printf("\n Inside func3() \n");
for(int count=0;count<=0XFFFFFFF;count++);
}
void func2(void)
{
printf("\n Inside func2() \n");
for(int count=0;count<=0XFFF;count++ );
func3();
}
void func1(void)
{
printf("\n Inside func1() \n");
for(int count=0;count<=0XFFFFFF;count++);
func2();
}
int main(void)
{
printf("\n main() beginnt...\n");
for(int count=0;count<=0XFFFFF;count++);
func1();
func4();
printf("\n main() ended...\n");
return 0;
}
Bitte beachten Sie, dass der oben gezeigte Code (test_gprof.c ) wurde speziell geschrieben, um Gprof zu erklären - es stammt aus keinem realen Projekt.
Der nächste Schritt besteht nun darin, diesen Code mit gcc zu kompilieren. Beachten Sie, dass ich den obigen Code idealerweise mit dem folgenden Befehl kompiliert hätte:
$ gcc -Wall -std=c99 test_gprof.c -o test_gprof
Aber da wir den Code mit Gprof profilieren müssen, muss ich das -pg verwenden Befehlszeilenoption, die vom gcc-Compiler bereitgestellt wird. Der Befehl wird also zu:
$ gcc -Wall -std=c99 -pg test_gprof.c -o test_gprof
Wenn Sie einen Blick auf die Manpage von gcc werfen, steht dort Folgendes über das -pg Möglichkeit:
"Generieren Sie zusätzlichen Code, um Profilinformationen zu schreiben, die für das Analyseprogramm gprof geeignet sind. Sie müssen diese Option verwenden, wenn Sie die Quelldateien kompilieren, über die Sie Daten wünschen, und Sie müssen sie auch beim Verknüpfen verwenden."
Kommen wir nun zurück zum obigen Befehl, nachdem er erfolgreich ausgeführt wurde, wird er eine Binärdatei namens test_gprof erzeugen in der Ausgabe. Der nächste Schritt besteht darin, diese ausführbare Datei zu starten. So habe ich die Binärdatei in meinem Fall gestartet:
$ ./test_gprof
Sobald der Befehl ausgeführt wurde, sehen Sie, dass eine Datei mit dem Namen gmon.out wird im aktuellen Arbeitsverzeichnis generiert.
$ ls gmon*
gmon.out
Diese Datei enthält alle Informationen, die das Gprof-Tool benötigt, um menschenlesbare Profildaten zu erstellen. Verwenden Sie nun das Gprof-Tool auf folgende Weise:
$ gprof test_gprof gmon.out> Profildaten.txt
Grundsätzlich lautet die generische Syntax dieses Befehls:
$ gprof [Name der ausführbaren Datei] gmon.out> [Name der Datei, die Profildaten enthalten wird]
Nun, bevor wir die Informationen sehen, die profile-data.txt Datei enthält, ist es erwähnenswert, dass die von Menschen lesbare Ausgabe, die Gprof erzeugt, in zwei Teile unterteilt ist:flaches Profil und Anrufdiagramm. Hier ist, was die Manpage von Gprof über Informationen in diesen beiden Abschnitten sagt:
"Das flache Profil zeigt, wie viel Zeit Ihr Programm in jeder Funktion verbracht hat und wie oft diese Funktion aufgerufen wurde. Wenn Sie einfach wissen möchten, welche Funktionen die meisten Zyklen verbrauchen, wird es hier kurz angegeben."
"Das Aufrufdiagramm zeigt für jede Funktion, welche Funktionen sie aufgerufen haben, welche anderen Funktionen sie aufgerufen hat und wie oft. Es gibt auch eine Schätzung, wie viel Zeit in den Unterroutinen jeder Funktion verbracht wurde. Dies kann darauf hindeuten Orte, an denen Sie versuchen könnten, Funktionsaufrufe zu eliminieren, die viel Zeit in Anspruch nehmen."
Ausgestattet mit diesen Informationen sind Sie jetzt in der Lage, die Daten in Ihrer Profiling-Ausgabedatei (profile-data.txt) besser zu verstehen in meinem Fall). Hier ist das flache Profil in meinem Fall:
Flaches Profil:
Jede Probe zählt als 0,01 Sekunden.
% kumulativer Selbstwert
Zeit Sekunden Sekunden Anrufe ms/Anruf ms/Anrufname
96,43 0.81 0.81 1 810.00 810.00 func3
3.57 0.84 0.03 1 30.00 840.00 func1
0.00 0.84 0.00 1 0.00 810.00 func2
0.00 0.84 0.00 1 0.0.0 1 0.0.0
Und hier ist, was jedes Feld bedeutet:
Fahren Sie fort, hier ist das Anrufdiagramm in meinem Fall:
Aufrufdiagramm (Erklärung folgt)
Granularität:Jeder Sample-Treffer deckt 4 Byte(s) für 1,19 % von 0,84 Sekunden ab
Index % Zeit selbst Kinder namens Name
0,03 0,81 1/1 main [2]
[1] 100,0 0,03 0,81 1 func1 [1]
0,00 0,81 1/1 func2 [3]
-- ---------------------------------------------
[2] 100.0 0.00 0.84 main [2]
0.03 0.81 1/1 func1 [1]
0.00 0.00 1/1 func4 [5]
---- -------------------------------------------
0,00 0,81 1 /1 func1 [1]
[3] 96,4 0,00 0,81 1 func2 [3]
0,81 0,00 1/1 func3 [4]
------------ -----------------------------------
0,81 0,00 1/1 func2 [3]
[4] 96,4 0,81 0,00 1 func3 [4]
--------------------------------- ----------- ---
0.00 0.00 1/1 main [2]
[5] 0.0 0.00 0.00 1 func4 [5]Die folgenden Screenshots erläutern die Informationen, die der Anrufgraph enthält:
Wenn Sie sich über die Quelle der obigen Screenshots wundern, lassen Sie mich Ihnen sagen, dass alle diese Informationen in der Ausgabedatei enthalten sind, die die Profilinformationen enthält, einschließlich Flat Profile und Call Graph. Falls Sie möchten, dass diese Informationen bei der Ausgabe weggelassen werden, können Sie das -b verwenden Option von Gprof bereitgestellt.
Fazit
Unnötig zu sagen, dass wir hier nur an der Oberfläche gekratzt haben, da Gprof viele Funktionen bietet (werfen Sie einfach einen Blick auf seine Manpage). Was auch immer wir hier behandelt haben, sollte jedoch ausreichen, um Ihnen den Einstieg zu erleichtern. Falls Sie Gprof bereits verwenden und etwas im Zusammenhang mit dem Tool mit allen hier teilen möchten, geben Sie einfach unten einen Kommentar ein.
