Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Einleitung
2 Die Installation
3 Erste Schritte
4 Linux als Workstation für Einsteiger
5 Der Kernel
6 Die Grundlagen aus Anwendersicht
7 Die Shell
8 Reguläre Ausdrücke
9 Konsolentools
10 Die Editoren
11 Shellskriptprogrammierung mit der bash
12 Die C-Shell
13 Benutzerverwaltung
14 Grundlegende Verwaltungsaufgaben
15 Netzwerkgrundlagen
16 Anwendersoftware für das Netzwerk
17 Netzwerkdienste
18 Mailserver unter Linux
19 LAMP
20 DNS-Server
21 Secure Shell
22 Die grafische Oberfläche
23 Window-Manager und Desktops
24 X11-Programme
25 Multimedia und Spiele
26 Prozesse und IPC
27 Bootstrap und Shutdown
28 Dateisysteme
29 Virtualisierung und Emulatoren
30 Softwareentwicklung
31 Crashkurs in C und Perl
32 Einführung in die Sicherheit
33 Netzwerksicherheit überwachen
A Lösungen zu den einzelnen Aufgaben
B Kommandoreferenz
C X11-InputDevices
D MBR
E Die Buch-DVDs
F Glossar
G Literatur
Stichwort

Download:
- ZIP, ca. 15,7 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Linux von Johannes Pl&ouml;tner, Steffen Wendzel
Das umfassende Handbuch
Buch: Linux

Linux
geb., mit 2 DVDs
1302 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1704-0
Pfeil 30 Softwareentwicklung
  Pfeil 30.1 Interpreter und Compiler
    Pfeil 30.1.1 C und C++
    Pfeil 30.1.2 Perl
    Pfeil 30.1.3 Java
    Pfeil 30.1.4 Tcl
    Pfeil 30.1.5 Was es sonst noch gibt
  Pfeil 30.2 Shared Libraries
    Pfeil 30.2.1 Vorteile der Shared Libraries
    Pfeil 30.2.2 Statisches Linken
    Pfeil 30.2.3 Die Dateien
  Pfeil 30.3 Debugging
    Pfeil 30.3.1 Vorbereitung
    Pfeil 30.3.2 Konsolenarbeit
    Pfeil 30.3.3 ddd
  Pfeil 30.4 Profiling
    Pfeil 30.4.1 Compiler-Option
    Pfeil 30.4.2 gprof verwenden
    Pfeil 30.4.3 Profiling-Daten lesen
  Pfeil 30.5 Tracing
  Pfeil 30.6 Hilfe beim Finden von Bugs
    Pfeil 30.6.1 ProPolice
    Pfeil 30.6.2 flawfinder und RATS
    Pfeil 30.6.3 Electric Fence
  Pfeil 30.7 Integrierte Entwicklungsumgebungen
  Pfeil 30.8 make
    Pfeil 30.8.1 Makefile
    Pfeil 30.8.2 Makefile-Makros
    Pfeil 30.8.3 Shellvariablen in Makefiles
    Pfeil 30.8.4 Einzelne Targets übersetzen
    Pfeil 30.8.5 Spezielle Targets
    Pfeil 30.8.6 Tipps im Umgang mit make
  Pfeil 30.9 Die GNU Autotools
  Pfeil 30.10 lex/flex und yacc/bison
    Pfeil 30.10.1 flex grundlegend anwenden
    Pfeil 30.10.2 bison/yacc grundlegend anwenden
  Pfeil 30.11 Unix-Software veröffentlichen
    Pfeil 30.11.1 Wichtige Dateien
  Pfeil 30.12 Manpages erstellen
    Pfeil 30.12.1 groff nutzen
    Pfeil 30.12.2 Die Manpage installieren
  Pfeil 30.13 Versionsmanagement
    Pfeil 30.13.1 CVS
    Pfeil 30.13.2 Subversion
  Pfeil 30.14 Wichtige Bibliotheken
    Pfeil 30.14.1 Entwicklung grafischer Oberflächen
    Pfeil 30.14.2 Weitere Bibliotheken
  Pfeil 30.15 Zusammenfassung
  Pfeil 30.16 Aufgaben


Galileo Computing - Zum Seitenanfang

30.4 Profiling  Zur nächsten ÜberschriftZur vorigen Überschrift

Eine andere Möglichkeit, sein Programm (oder das von anderen Entwicklern) zu untersuchen, ist das Profiling. Dabei wird untersucht, wie viel Zeit ein Programm mit welchen Tätigkeiten verbringt, welche Funktionen wie oft aufgerufen werden und wie viel Zeit diese dabei benötigen. Der primäre Einsatzzweck des Profilings ist also kurz gesagt das Performance-Tuning.


Galileo Computing - Zum Seitenanfang

30.4.1 Compiler-Option  Zur nächsten ÜberschriftZur vorigen Überschrift

Zum Profiling wird ein Programm, der sogenannte Profiler eingesetzt. Unter Linux und BSD ist dies standardmäßig der GNU-Profiler gprof. Um diesen jedoch zu nutzen, muss bei der Übersetzung des Quellcodes, ähnlich wie beim GNU-Debugger, die Compiler-Option für das Profiling (-gp) eingebaut werden.

$ gcc -o myprog myprog.c -pg

Listing 30.24  Beispiel zur Übersetzung mit Profiling


Galileo Computing - Zum Seitenanfang

30.4.2 gprof verwenden  Zur nächsten ÜberschriftZur vorigen Überschrift

Führt man nun ein für das Profiling übersetztes Programm aus, erzeugt dieses Programm im Arbeitsverzeichnis eine Datei namens gmon.out. In dieser sind die Informationen enthalten, die der Profiler benötigt, um für den Entwickler einen Report zu generieren.

Um diese Datei nun zu interpretieren, verwendet man das Tool gprof. Dabei werden sehr viele Informationen auf dem Bildschirm ausgegeben, weshalb man am besten eine Ausgabeumlenkung verwendet und sich die Ausgabe mit einem Editor ansieht.

$ gprof myprog >report

Listing 30.25  gprof aufrufen


Galileo Computing - Zum Seitenanfang

30.4.3 Profiling-Daten lesen  topZur vorigen Überschrift

Nachdem man nun einen Profiling-Report erzeugt hat, muss man nur noch wissen, wie dieser eigentlich zu interpretieren ist. Einen Ausschnitt eines fertigen Reports zeigt Ihnen das folgende Listing:

called/total       parents
index  %time  self descendents  called+self    name      index
called/total       children
<spontaneous>
[1]    100.0  0.01        0.00             write [1]
-----------------------------------------------
[2]      0.0    0.00        0.00     4+4  <cycle 1 as a whole>  [2]
0.00        0.00     5      imalloc <cycle 1> [9]
0.00        0.00     3      malloc_bytes <cycle 1> [11]
-----------------------------------------------
[3]      0.0    0.00        0.00    12+2  <cycle 2 as a whole>  [3]
0.00        0.00    13       vfprintf <cycle 2> [6]
0.00        0.00     1       __sbprintf <cycle 2> [468]
-----------------------------------------------
...
...
...
%   cumulative   self              self     total
time   seconds   seconds calls  ms/call  ms/call  name
100.0       0.01     0.01                          write [1]
0.0       0.01     0.00   406     0.00     0.00  mbtowc [4]
0.0       0.01     0.00    20     0.00     0.00  __sfvwrite [457]
0.0       0.01     0.00    20     0.00     0.00  __sprint [458]
0.0       0.01     0.00    13     0.00     0.00  localeconv [5]
0.0       0.01     0.00    13     0.00     0.00  vfprintf <cycle 2>
[6]
0.0       0.01     0.00    12     0.00     0.00  __sflush [459]
0.0       0.01     0.00    12     0.00     0.00  __swrite [460]
0.0       0.01     0.00    12     0.00     0.00  fflush [7]
0.0       0.01     0.00     9     0.00     0.00  printf [8]...
...

Listing 30.26  Profiling-Report (Auszug)

Der Report ist in zwei Teile, den Call Graph und das Flat Profile, gegliedert. Im oberen Listing ist zunächst ein Auszug aus dem Call Graph und darunter ein Auszug aus dem Flat Profile zu sehen.

Call Graph

Der Call Graph gibt dem Entwickler Aufschluss darüber, wie viel Zeit eine Funktion und die von ihr aufgerufenen Funktionen benötigt haben. Dabei kann es durchaus vorkommen, dass eine Funktion selbst nicht viel Zeit verbraucht hat, die von ihr aufgerufenen Funktionen jedoch äußerst viel Zeit benötigten. Auf diese Weise lässt sich leicht überprüfen, an welchen Stellen die Software am langsamsten ist.

Die Spalte index gibt dabei den Index einer Funktion an, und %time gibt den prozentualen Anteil an der Gesamtlaufzeit des Programms an, der für diese Funktion verwendet wurde.

self gibt die Zeit an, die die Funktion selbst benötigte, und descendents die Zeit, die für die Funktionen verwendet wurde, die von dieser Funktion aufgerufen wurden.

Die called-Spalte zeigt dem Entwickler, wie oft die Funktion aufgerufen (und dabei von sich selbst aufgerufen (self)) wurde. Die beiden letzten Spalten geben den Funktionsnamen bzw. die Namen der von der Funktion aufgerufenen Funktionen sowie deren Index-Nummer an.

Flat Profile

Das Flat Profile gibt Ihnen die gesamte Zeit an, die ein Programm zur Ausführung einer Funktion verwendet hat. Dabei sind die Funktionen in der Reihenfolge ihres Zeitbedarfs sortiert.

Die erste Spalte gibt dabei eben diesen prozentualen Zeitanteil an, und in Spalte Nummer zwei (Cumulative Seconds) ist die dafür (und für die von dieser Funktion aufgerufenen Funktionen) notwendige Zeit in Sekunden angegeben. Die Spalte self seconds gibt hingegen nur die Zeit an, die für die Funktion selbst verbraucht wurde, was also die von ihr aufgerufenen Funktionen ausschließt.

calls ist die Anzahl der Aufrufe einer Funktion. self ms/call steht für die Millisekunden, die für einen Aufruf der Funktion selbst gebraucht wurden, und total ms/call steht für die Millisekunden, die für einen Aufruf der Funktion sowie der von ihr aufgerufenen Funktionen gebraucht wurden. Die letzte Spalte gibt wie beim Call Graph den Funktionsnamen sowie deren Call Graph-Index an.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  Zum Katalog
Zum Katalog: Linux, Ausgabe 2011






Linux, Ausgabe 2011
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Linux-Server






 Linux-Server


Zum Katalog: Linux Hochverfügbarkeit






 Linux Hoch-
 verfügbarkeit


Zum Katalog: LPIC-1






 LPIC-1


Zum Katalog: Debian GNU/Linux






 Debian GNU/Linux


Zum Katalog: openSUSE 11.2






 openSUSE 11.2


Zum Katalog: Shell-Programmierung






 Shell-Programmierung


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2011
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de