1

page 1 (1 pages)

Rechenzentrum

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAAProgrammentwicklung

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAAunter UNIX

AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA
AAAA

Define the problem

Design an algorithm

to solve the problem

Edit source files

Compile source files

Link object files and libraries

Test executable program

(reliable results, speed,

user interface, ...)

THINK ...

Programmentwicklung unter UNIX

Autor: Frank Elsner

Adresse: Universit?t Osnabr?ck

- Rechenzentrum -

Albrechtstrafle 28

D-49076 Osnabr?ck

E-Mail: F.Elsner@rz.uni-osnabrueck.de

Version: 1.1

Stand: 05.07.94

Dateiname E:DOCUNIXHB_UNIXP.DOC

anonymous FTP ftp.rz.uni-osnabrueck.de

pub/reports/prog_unix-1.1.ps

Inhaltsverzeichnis

1. Einleitung.....................................................................................................................1

Voraussetzungen, Zielsetzung und Gliederung ........................................................1

Abh?ngigkeiten.......................................................................................................1

Verwendete typografische Konventionen ................................................................2

Namenskonventionen f?r Dateien............................................................................2

Weiterf?hrende Literatur ........................................................................................3

2. Anmelden und Einrichten der Umgebung......................................................................4

telnet, login - Anmelden im System .........................................................................4

bsh, csh, ksh, chsh - Ausw?hlen eines Kommandointerpreters .................................4

setup - Setzen von Umgebungsvariablen .................................................................5

exit - Abmelden aus dem System.............................................................................5

3. Werkzeuge zur Programmentwicklung .........................................................................6

Entwickeln von Programmen ..................................................................................6

vi, xlc, xlf - Entwickeln von "kleinen" Programmen.................................................6

man, info - Anzeigen von Online-Informationen ......................................................8

ar, dbx, ... - Entwickeln von Programmen (unabh?ngig von der Sprache) ................8

xlc, cflow, ... - Entwickeln von C Programmen .......................................................8

xlf, ftnchek, ... - Entwickeln von Fortran Programmen ............................................9

awk, perl, ... - L?sen spezieller Probleme ................................................................9

find, grep, sort - Sortieren und Suchen....................................................................9

ftp, mail, ... - Versenden und Drucken von Dateien und E-Mail ...............................9

4. info - Abrufen von Online-Informationen ......................................................................10

Aufrufen des InfoExplorer Systems.........................................................................10

Wechseln zwischen Men?- und Textmodus .............................................................10

Navigieren im Textmodus .......................................................................................10

5. vi - Erfassen und Bearbeiten von Textdateien ...............................................................11

Starten, Speichern und Beenden..............................................................................11

Laden und Speichern von Dateien und Beenden der Sitzung ...................................12

Einf?gen und Korrigieren von Text .........................................................................12

Zeilenweises L?schen, Verschieben und Kopieren von Text ....................................12

Bewegen im Text und Markieren von Bereichen .....................................................12

Suchen und Ersetzen von Zeichenketten und regul?ren Ausdr?cken ........................13

Trennen und Zusammenf?gen von Zeilen ................................................................13

Ausf?hren von Shell Kommandos, Wiederholen und R?ckg?ngigmachen ................13

Anzeigen und ?ndern von Optionen .......................................................................14

6. make - Regelbasiertes Generieren von Programmen......................................................15

Erstellen einer make Beschreibungsdatei .................................................................15

Erzeugen des ausf?hrbaren Programmes .................................................................17

7. xlc - ?bersetzen und Binden von C Programmen ..........................................................19

?bersetzen, Binden und Starten ..............................................................................19

Auflisten der Optionen und Argumente ...................................................................19

Erstellen einer make Beschreibungsdatei .................................................................20

8. xlf - ?bersetzen und Binden von Fortran Programmen..................................................21

?bersetzen, Binden und Starten ..............................................................................21

Auflisten der Optionen und Argumente ...................................................................21

Verwenden nicht-portabler xlf Erweiterungen .........................................................22

Erstellen einer make Beschreibungsdatei (Makefile) ................................................22

9. ar - Verwalten von Bibliotheken ...................................................................................23

Erstellen einer Bibliothek ........................................................................................23

Auflisten wichtiger Optionen und Argumente..........................................................23

10. dbx, gprof - Suchen von Fehlern und Messen von Programmen ....................................24

Durchf?hren einer Debug-Sitzung...........................................................................24

Durchf?hren einer Zeitmessung...............................................................................25

Durchf?hren einer Laufzeitanalyse ..........................................................................26

11. co - Verwalten von unterschiedlichen Programmversionen............................................27

Ein- und Auschecken ..............................................................................................27

Anzeigen des Protokolls aller ?nderungen ..............................................................28

Verwenden einer make Beschreibungsdatei .............................................................29

12. ?berblick ?ber Standardbibliotheken ............................................................................30

Verwenden von Standardbibliotheken .....................................................................30

Zordnen der verf?gbaren Dateien............................................................................30

13. ?berblick ?ber numerische Bibliotheken .......................................................................31

Verwenden von numerischen Bibliotheken ..............................................................31

Zordnen der verf?gbaren Dateien............................................................................31

Verwenden von Computeralgebrasystemen .............................................................32

14. ?berblick ?ber Graphik-Bibliotheken und -Programme.................................................34

Verwenden von Graphik-Bibliotheken und -Programmen........................................34

Drucken und Plotten ...............................................................................................34

Anhang ..............................................................................................................................36

make Beschreibungs- oder Steuerdatei (Makefile)...................................................36

Einleitung

1. Einleitung

Dieses Handbuch wendet sich an Programmierer, die auf einem UNIX System vornehmlich mit

den Programmiersprachen C, C++ und Fortran Programme entwickeln wollen.

Voraussetzungen, Zielsetzung und Gliederung

Grundlegende Kenntnisse ?ber das An- und Abmelden bei einem UNIX System, das Aufrufen

von Kommandos und das Erzeugen und Verwalten von Dateien und Verzeichnissen, wie sie im

Rahmen eines Einf?hrungskurses in UNIX erworben werden, werden vorausgesetzt. Ferner

werden grundlegende Kenntnisse der Programmiersprachen C, C++ und/oder Fortran und der

Vorgehensweise bei der Entwicklung von Programmen vorausgesetzt. (Dieses Handbuch ist

kein Lehrbuch ?ber Programmieren in C, C++ oder Fortran.)

In diesem Handbuch werden schwerpunktm?flig folgende Fragen behandelt:

?? Welche Werkzeuge stehen unter UNIX zur Programmentwicklung zur Verf?gung?

?? Welche Systembibliotheken und welche numerischen und graphischen Bibliotheken

stehen unter UNIX zur Verf?gung?

Das Handbuch ist folgendermaflen gegliedert:

? Die ersten Kapitel beschreiben die Werkzeuge zur Entwicklung von Programmen, wobei

der Schwerpunkt auf C und Fortran Programmierung liegt.

? Die folgenden Kapitel geben einen ?berblick ?ber Systembibliotheken, numerische Biblio-

theken und Bibliotheken zur Visualisierung numerischer Ergebnisse.

Abh?ngigkeiten

Als Grundlage der Beschreibung dient eine Workstation IBM RISC/6000 des Rechenzentrums

(titan.rz.Uni-Osnabrueck.DE) unter dem Betriebssystem AIX, einem UNIX Derivat.

Die Beschreibung l?flt sich, mit einigen Einschr?nkungen (z.B. Existenz und Pfadnamen von

Kommandos und Bibliotheken, unterschiedliche Compiler und Compiler-Optionen), auch auf

andere UNIX Systeme ?bertragen.

- 1 -

Einleitung

Erkundigen Sie sich ggf. bei einem lokalen Experten, wie Sie sich eine entsprechende Umge-

bung auf Ihrem UNIX System einrichten k?nnen.

Verwendete typografische Konventionen

Fettschrift Fettschrift bezeichnet Definitionen, Kommandos oder wichtige Textpassa-

gen.

Beispiel: Das Kommando xlc ruft den IBM C Compiler auf.

Kursivschrift Kursivschrift bezeichnet englische Fachausdr?cke oder Variablen, die durch

konkrete Werte zu ersetzen sind.

Beispiel: Geben Sie eine beliebige Zahl n ein.

[...] Eckige Klammern bezeichnen optionale Syntaxelemente.

Beispiel: vi [filename ...]

<...> Spitze Klammern bezeichnen Umschalttasten, die zusammen mit einer weite-

ren Taste (oder zwei weiteren Tasten) eingegeben werden.

Beispiel: Geben Sie die Tastenkombination <CTRL>+V ein.

Courier Schreibmaschinenschrift bezeichnet Kommandos, Dateinamen oder Pro-

grammbeispiele. Dateien sind zus?tzlich mit einem Rahmen umgeben.

Beispiel: Die mathematische Standardbibliothek heiflt /usr/lib/libm.a.

$ ... Das Zeichen $ symbolisiert die Eingabeaufforderung des Kommandointerpre-

ters, hinter dem Sie Kommandos eingeben. Die Benutzereingabe ist durch

Fettschrift ausgezeichnet. Sie m?ssen Kommandos immer durch <CR>

(Enter) best?tigen (ausf?hren).

# ... Hinter dem Zeichen # folgt Kommentar, d.h. eine kurze Erl?uterung:

Beispiel: $ vi sample5.c # starts the vi editor.

Namenskonventionen f?r Dateien

Wie unter UNIX ?blich und (oftmals erforderlich !) werden in diesem Handbuch folgende En-

dungen f?r Dateinamen verwendet:

- 2 -

Einleitung

Endung Bedeutung Beispiel

.a Bibliothek libm.a

.C C++ Quelltextdatei sample1.C

.c C Quelltextdatei sample1.c

.f Fortran 77 Quelltextdatei sample2.f

.f90 Fortran 90 Quelltextdatei sample3.f90

.h C Deklarationsdatei

(C Header File)

stdio.h

.o Objektdatei sample1.o

keine Endung ausf?hrbares Programm sample

Weiterf?hrende Literatur

In diesem Handbuch werden einige Problemfelder nur angeschnitten, zum anderen sind die Be-

schreibungen von Kommandos und Bibliotheken aus Platzmangel unvollst?ndig. Abh?ngig von

Ihren konkreten Aufgaben ben?tigen Sie weiterf?hrende Literatur, z.B. die genaue C und/oder

Fortran Sprachbeschreibung oder die Referenzdokumentation f?r die Compiler oder die

Bibliotheksfunktionen.

Aufgrund des Umfangs der zur Verf?gung stehenden Literatur1 sei an dieser Stelle nur auf die

Benutzerhandb?cher zum IBM C bzw. Fortran Compiler (IBM xlc C Compiler User's Guide

bzw. IBM xlf Fortran Compiler User's Guide) und einige B?cher aus der O'Reilly UNIX

Nutshell Serie (Learning the vi Editor, UNIX for Fortran Programmers, Using C on a UNIX

System, Managing Projects with make) verwiesen, die ihrerseits wieder umfangreiche Litera-

turhinweise enthalten.

Die genannten Handb?cher und B?cher stehen Ihnen in der RZ Bibliothek zur Einsicht und

Kurzentleihe zur Verf?gung.

1 Nehmen Sie sich bei Gelegenheit die Zeit und st?bern und sichten Sie in einschl?gigen Buchhandlungen,

welche B?cher zum Thema UNIX verf?gbar sind.

- 3 -

Anmelden und Einrichten der Umgebung

2. Anmelden und Einrichten der Umgebung

In diesem Kapitel werden die Verfahren zum An- und Abmelden und die M?glichkeiten zur

Konfiguration einer benutzerspezifischen Umgebung beschrieben. Auf lokale Besonderheiten

der UNIX Workstation Systeme des RZ wird besonders hingewiesen.

telnet, login - Anmelden im System

Geben Sie zun?chst das telnet Kommando ein, um sich bei einem UNIX System des RZ mit

Internet-Namen hostname.rz.Uni-Osnabrueck.DE anzumelden. F?r hostname k?nnen Sie

z.B. titan einsetzen:

$ telnet titan.rz.Uni-Osnabrueck.DE # starts terminal emulation.

Danach werden Sie durch das login Kommando automatisch aufgefordert, Benutzerkennung

(user identification, login name) und Passwort (password) einzugeben, um sich gegen?ber

dem System zu authentisieren, hier z.B. mueller und geheim12.:

password: geheim12.

bsh, csh, ksh, chsh - Ausw?hlen eines Kommandointerpreters

Die bekanntesten Kommando-Interpreter unter UNIX sind die Bourne Shell bsh, die Korn

Shell ksh und die C Shell csh.

Der Systemadministrator hat in der Datei /etc/passwd einen Kommando-Interpreter vorein-

gestellt. Diese Voreinstellung k?nnen Sie bei Bedarf mit dem chsh Kommando interaktiv ver-

?ndern2:

$ chsh # changes login shell.

Die folgenden Konfigurationsdateien beziehen sich auf den Korn Shell Kommando-Interpreter

ksh, der auf den RISC/6000 Systemen des RZ voreingestellt ist.

2 In diesem Skript wird ausschliefllich die Korn Shell verwendet.

- 4 -

Anmelden und Einrichten der Umgebung

Zu Beginn jeder Sitzung wird automatisch die Systemdatei /etc/profile ausgef?hrt. Sie

k?nnen in einer eigenen Konfigurationsdatei $HOME/.profile festlegen, welche weiteren

Kommandos automatisch ausgef?hrt werden sollen, wenn Sie eine Sitzung beginnen. Dar-

?berhinaus k?nnen Sie in einer eigenen ksh Konfigurationsdatei festlegen, welche Kommandos

bei jedem Aufruf des ksh Kommando-Interpreters ausgef?hrt werden sollen:

Konfigurationsdatei ... wird ausgef?hrt ... ver?nderbar durch

/etc/profile zu Beginn der Sitzung Systemadministrator

$HOME/.profile zu Beginn der Sitzung Eigent?mer

$HOME/.kshrc bei jedem Aufruf von ksh Eigent?mer

setup - Setzen von Umgebungsvariablen

Das vom RZ entwickelte setup Kommando informiert in knapper Form ?ber verf?gbare Pro-

dukte und richtet Umgebungen f?r Produkte ein. Eine detaillierte Auflistung aller verf?gbaren

Produkte erhalten Sie durch:

$ setup -al3

Zweckm?fligerweise richten Sie die Umgebungen f?r ben?tigte Produkte sofort nach dem An-

melden ein. Das folgende Beispiel zeigt m?gliche Eintr?ge in der Konfigurationsdatei

$HOME/.profile:

export TERM=vt220 # sets/exports TERM variable.

stty echoe ^H # enables backspace.

set -o emacs # enables command-line editing.

setup elm vast90 f90 # sets up environment for

# elm mail and some f90 tools.

exit - Abmelden aus dem System

Beenden Sie Ihre Sitzung durch Eingabe des Kommandos exit bzw. durch Eingabe der Ta-

stenkombination <CTRL>+D:

$ exit

3 Hinter setup verbirgt sich folgendes alias Kommando: ". /usr/misc/setup/setup.sh". Sie k?nnen also auch

schreiben: . /usr/misc/setup/setup.sh -al

- 5 -

Werkzeuge zur Programmentwicklung

3. Werkzeuge zur Programmentwicklung

In diesem Kapitel erhalten Sie eine Auflistung wichtiger Kommandos zur Programmentwick-

lung4. In den folgenden Kapiteln werden einige ausgew?hlte Kommandos genauer behandelt.

Sie k?nnen sich mittels der Kommandos man oder info eine Online-Beschreibung aller ver-

f?gbaren Kommandos anzeigen lassen.

Entwickeln von Programmen

Sie entwickeln Programme zur L?sung von Problemen und f?hren diese Programme auf einem

Computersystem aus. Hieraus folgt, dafl Sie Kenntnisse aus verschiedenen Bereichen aktivie-

ren und verkn?pfen m?ssen.

Sie haben also die Aufgabe,

1. (Fachwissen in einem Anwendungsgebiet)

ein bestehendes Problem durch einen Algorithmus zu l?sen,

2. (Kenntnis einer Programmiersprache)

den Algorithmus in eine Programmiersprache umzusetzen,

3. (Kenntnis einer Entwicklungsumgebung)

die Quelldatei der gew?hlten Programmiersprache zu ?bersetzen, zu binden, auszuf?hren

und die Ergebnisse kritisch zu ?berpr?fen.

Dieses Handbuch befaflt sich vornehmlich mit dem 3. Punkt, d.h. mit der Frage, welche Werk-

zeuge zur Entwicklung von Programmen zur Verf?gung stehen.

vi, xlc, xlf - Entwickeln von "kleinen" Programmen

Die wesentlichen Werkzeuge zur Programmentwicklung sind Editor, Compiler und Linker.

Die im folgenden behandelten Compiler xlf und xlf90 (f?r Fortran 77 und Fortran 90) und

xlc und xlC (f?r C und C++) rufen den Linker ld automatisch auf.

4 Das UNIX Betriebssystem ist mit einer Vielzahl von "kleinen" n?tzlichen Kommandos ausgestattet, die

nahezu beliebig kombiniert werden k?nnen. Hierzu werden Datenstr?me ?ber Pipelines durch die Werkzeuge

geleitet und in jedem Werkzeug einem Arbeitsschritt unterworfen (in Analogie zu einem am Flieflband

zusammengesetzten Auto). Diese St?rke von UNIX, komplexe Arbeiten in eine Vielzahl von kleinen Schritten

zu erledigen, erschlieflt sich dem Neuling allerdings erst nach einer gewissen Eingew?hnungszeit.

- 6 -

Werkzeuge zur Programmentwicklung

Sprache/

Aufgabe

Fortran 77 Fortran 90 C C++

Erfassen des

Quelltextes

vi sample1.f vi sample2.f90 vi sample3.c vi sample4.f

?bersetzen

und Binden

xlf -o sample1

sample1.f

xlf90 -o sample2

sample2.f90

xlc -o sample3

sample3.c

xlC -o sample4

sample4.C

Ausf?hren

des Pro-

gramms

sample1 sample2 sample3 sample4

In der Regel treten bei der ?bersetzung (Schritt 2) oder bei der Ausf?hrung (Schritt 3) Fehler

auf, die sukzessive eliminiert werden. Das Entwickeln von Programmen stellt demnach einen

iterativen Prozefl dar, der de facto nie beendet wird, weil ein Programm immer weiter entwik-

kelt werden kann (durch Beseitigen von Fehlern und/oder Hinzuf?gen neuer Eigenschaften):

Edit C source file

vi sample3.c

C source file

sample3.c

Compile and link

xlc -o sample3 sample3.c

Executable program

sample3

Run executable program

sample3

Start

Stop

- 7 -

Werkzeuge zur Programmentwicklung

Neben diesen elementaren Werkzeugen zur Programmentwicklung gibt es weitere UNIX

Werkzeuge, die in der Regel bei gr?fleren Entwicklungsprojekten verwendet werden. Es ist al-

lerdings prinzipiell (!) m?glich, sich mit den oben genannten beiden Werkzeugen, n?mlich Edi-

tor und Compiler, zu begn?gen.

Im folgenden erhalten Sie einen ?berblick ?ber die verf?gbaren Werkzeuge - Sie sollten sich,

entsprechend Ihrem Arbeitsstil und/oder den Vorgaben des Projektes in Ihrer t?glichen Arbeit

konsequent auf einige ausgew?hlte Werkzeuge beschr?nken5. Die folgenden Abschnitte stellen

wichtige Werkzeuge nach Aufgabengebieten zusammen.

Verwenden Sie ggf. das man Kommando, um sich die Syntax und weitere Erl?uterungen direkt

am Bildschirm anzeigen zu lassen, z.B. f?r den xlc Compiler durch:

$ man xlc

man, info - Anzeigen von Online-Informationen

info ruft das IBM InfoExplorer Informationssystem auf.

man liefert eine Online Beschreibung eines Kommandos.

ar, dbx, ... - Entwickeln von Programmen (unabh?ngig von der Sprache)

ar verwaltet Objektbibliotheken.

dbx dient zum kontrollierten Ausf?hren von Programmen (Debugging).

ld bindet Objektdateien und Bibliotheken zu ausf?hrbaren Programmen.

nm listet Symbole in Objektdateien und Bibliotheken auf.

make automatisiert die Generierung von Programmen.

gprof dient zur Laufzeitanalyse von Programmen.

sccs/rcs verwaltet Versionen von Dateien eines Projektes.

size zeigt die Gr?fle der Segmente in einem Programm an.

strip entfernt die Symboltabelle aus einem Programm.

vi, emacs erzeugt und bearbeitet Textdateien.

xlc, cflow, ... - Entwickeln von C Programmen

cb verbessert das Layout von C Quellen.

5 Der Autor arbeitet mit vi, xlf, xlc, xlf90, xlC, make, ar, rcs, cextract, dbx und gprof und teilweise mit

integrierten Entwicklungsumgebungen unter Windows und UNIX (softbench).

- 8 -

Werkzeuge zur Programmentwicklung

cextract extrahiert Funktionsbeschreibungen aus C Quellen.

cflow stellt den Kontrollflufl in einem C Programm dar.

cxref erzeugt Kreuzreferenzen zwischen Funktionen.

lint f?hrt eine genaue syntaktische und semantische Analyse durch.

xlc ?bersetzt und bindet C Programme.

xlf, ftnchek, ... - Entwickeln von Fortran Programmen

fsplit trennt eine Fortran Quelldatei nach Programm-Einheiten auf.

ftnchekf?hrt eine genaue syntaktische und semantische Analyse durch.

xlf ?bersetzt und bindet Fortran 77 Programme.

f90, xlf90 ?bersetzt und bindet Fortran 90 Programme.

vast90 konvertiert zwischen Fortran 77 und Fortran 90 Programmen.

awk, perl, ... - L?sen spezieller Probleme

awk, perl dient zur Mustererkennung und -verarbeitung.

lex erzeugt Scanner f?r lexikalische Analyse.

sed bearbeitet Textdateien (stream editor).

yacc erzeugt Parser f?r syntaktische Analyse.

find, grep, sort - Sortieren und Suchen

find sucht Dateien unter vorgegebenen Bedingungen.

grep sucht in Dateien nach regul?ren Ausdr?cken.

sort sortiert in Dateien nach vorgegebenen Feldern.

ftp, mail, ... - Versenden und Drucken von Dateien und E-Mail

ftp sendet oder empf?ngt Dateien im Netzwerk.

lpr druckt eine Datei auf einem ausgew?hlten Drucker/Plotter.

mail, elm sendet und empf?ngt E-Mail.

Die Liste ist bei weitem nicht vollst?ndig6. Sie enth?lt eine Auswahl von Standard UNIX

Kommandos und weiteren kommerziell verf?gbaren (z.B. vast90) und Public Domain Produk-

ten (z.B. rcs).

6 Konsultieren Sie z.B. das Verzeichnis /usr/bin und /usr/local/bin.

- 9 -

info - Abrufen von Online-Informationen

4. info - Abrufen von Online-Informationen

In diesem Kapitel wird in K?rze das IBM Informationssystem InfoExplorer vorgestellt, das

u.a. Informationen zu allen Kommandos enth?lt (nur RISC/6000). Online Dokumentation zu

jedem einzelnen Kommando in der UNIX ?blichen Form (Manual Page) k?nnen Sie dar?ber-

hinaus ?ber das man Kommando abrufen.

Aufrufen des InfoExplorer Systems

Sie rufen InfoExplorer ?ber das info Kommando auf:

$ info

Die folgende Kurzbeschreibung bezieht sich auf die zeilenorientierte Benutzeroberfl?che.

Wechseln zwischen Men?- und Textmodus

Im InfoExplorer befinden Sie sich entweder im Men?- oder im Textmodus. Sie gelangen

durch Eingabe von <CTRL>+o in die Men?zeile. In der Men?zeile k?nnen Sie durch Dr?cken

der Cursortasten zwischen verschiedenen Men?punkten wechseln und durch Dr?cken der

Eingabetaste einen Men?punkt ausw?hlen. Falls Sie einen Artikel ausgew?hlt haben, wechselt

InfoExplorer automatisch in den Textmodus und zeigt den ausgew?hlten Artikel an.

Durch Auswahl von Exit beenden Sie die InfoExplorer Sitzung. Es steht Ihnen u.a. ein

Men?punkt Help zur Verf?gung steht, in dem ein ?berblick ?ber InfoExplorer und seine

Bedienung gegeben wird.

Navigieren im Textmodus

Im Textmodus stehen Ihnen folgende Kommandos zur Verf?gung:

Tastenkombination Funktion

<CTRL>+o wechselt zwischen Men?- und Textmodus.

<CTRL>+n bl?ttert eine Seite vor (next).

<CTRL>+p bl?ttert eine Seite zur?ck (previous).

<CTRL>+f springt zum n?chsten Stichwort (forward).

<CTRL>+b springt zum vorhergehenden Stichwort (backward).

Cursortasten bewegen den Cursor im Text.

- 10 -

vi - Erfassen und Bearbeiten von Textdateien

5. vi - Erfassen und Bearbeiten von Textdateien

In diesem Kapitel wird der Editor vi (visual editor) behandelt. vi ist ein kommando-orientier-

ter Editor, mit dem Textdateien bearbeitet werden k?nnen. Der vi ist grunds?tzlich auf jedem

UNIX System vorhanden und stellt deshalb den "kleinsten gemeinsamen Nenner" bei der Text-

erfassung -und bearbeitung unter UNIX dar.

Das Bearbeiten von Texten geh?rt zu den h?ufigsten T?tigkeiten, speziell bei der Programm-

entwicklung. Die in diesem Kapitel gegebene Referenz ist deshalb sehr ausf?hrlich. Sie sollten

sich m?glichst fr?hzeitig und intensiv mit den M?glichkeiten des vi Editors (oder eines ande-

ren Editors wie z.B. emacs oder the) auseinandersetzen.

Starten, Speichern und Beenden

Geben Sie folgendes Kommando zum Start des vi Editors ein, wobei im Beispiel die Datei

sample1.f geladen bzw. neu erzeugt wird:

$ vi sample1.f

Die wichtigste Taste zur Bedienung des vi ist die ESCAPE Taste (im folgenden mit <ESC> be-

zeichnet), die jederzeit einen Wechsel in den Kommando-Modus bewirkt:

<ESC> # always changes to command mode.

Ein Wechsel in den Texteingabe-Modus erfolgt u.a. durch Eingabe von <ESC> und eines der

Kommandos i,a ,I und A und wird durch <ESC> wieder beendet. Sie k?nnen eine Textein-

gabe auch als ein ?langes? Kommando der Form <ESC>itext<ESC> interpretieren, mit dem

Sie den Text text eingeben:

<ESC> i text<ESC> # inputs text into current file.

Ein Wechsel in den Systemzeilen-Modus erfolgt durch Eingabe von <ESC> und eines der

Kommandos :, ! und ?. Der Cursor springt in die letzte Bildschirmzeile, und Sie k?nnen nun

eines der Subkommandos eingeben. Ein Subkommando und die folgenden Argumente m?ssen

mit der <CR> Taste (Enter) abgeschlossen werden.

Die folgende Beschreibung setzt den Kommandomodus voraus. Sie k?nnen jederzeit <ESC>

(auch mehrmals hintereinander) eingeben, um diese Voraussetzung herzustellen

- 11 -

vi - Erfassen und Bearbeiten von Textdateien

Laden und Speichern von Dateien und Beenden der Sitzung

Kommando Bedeutung

: n wechselt zur n?chsten geladenen Datei.

: e! file l?dt die Datei file als neue aktuelle Datei.

: wq! sichert die bearbeiteten Dateien und beendet die vi Sit-

zung.

: w! [file] sichert die aktuelle Datei [unter dem Namen file].

: q! beendet die Sitzung, ohne die bearbeiteten Dateien zu

sichern.

: q beendet die Sitzung.

<CTRL+A> wechselt zur vorhergehenden geladenen Datei.

: args zeigt die geladenen Dateien an, die aktuelle hervorge-

hoben durch eckige Klammern.

Einf?gen und Korrigieren von Text

a text <ESC> f?gt den Text text ein (Anh?ngen).

i text <ESC> f?gt den Text text ab Cursorposition ein.

A text <ESC> f?gt den Text text am Ende der Zeile ein (Anh?ngen).

I text <ESC> f?gt den Text text am Anfang der Zeile ein.

cw text <ESC> ersetzt das n?chste Wort durch text.

c$ text <ESC> ersetzt den Rest der Zeile durch text.

<BACKSPACE> l?scht Zeichen w?hrend des Einf?gens.

<CTRL+V> maskiert ein nicht-druckbares Zeichen.

: r file f?gt die Datei file ab Cursorposition ein.

Zeilenweises L?schen, Verschieben und Kopieren von Text

[n] dd l?scht eine [oder n] Zeilen .

d$ l?scht den Rest der Zeilen.

[n] yy kopiert eine [oder n] Zeilen in einen Puffer.

y$ kopiert den Rest der Zeilen in einen Puffer.

[n] P f?gt Puffer vor Cursorposition ein.

[n] p f?gt Puffer ab Cursorposition ein.

"x [n] yy kopiert in den benannten Puffer x (x=a,...z)..

"x p f?gt Inhalt von Puffer x ab Cursorposition ein.

Bewegen im Text und Markieren von Bereichen

<CTRL> G zeigt die aktuelle Zeilennummer an.

: set nu zeigt am linken Rand permanent Zeilennummern an.

- 12 -

vi - Erfassen und Bearbeiten von Textdateien

h (j, k, l) bewegt Cursor nach links (oben, unten und rechts).

positioniert am Zeilenanfang.

$ positioniert am Zeilenende.

1G positioniert am Dateianfang.

G positioniert am Dateiende.

n G positioniert an der Zeile mit der Nummer n.

<CTRL+ F> rollt einen Bildschirm nach unten.

<CTRL+ B> rollt einen Bildschirm nach oben.

mc setzt eine Marke c an die Cursorposition (c=a, ..., z).

`c positioniert an Marke c

Suchen und Ersetzen von Zeichenketten und regul?ren Ausdr?cken

/text sucht W?rter, die mit text beginnen, in Richtung Da-

teiende.

?text sucht W?rter, die mit text beginnen, in Richtung Da-

teianfang.

n wiederholt letzte Suche.

N wiederholt letzte Suche in umgekehrter Richtung.

% sucht zur aktuellen Klammer die ?ffnende bzw.

schlieflende.

:%s/old/new/gc ersetzt ?berall old durch new mit Abfrage

(y: Best?tigung, <CR>: nicht ersetzen).

Trennen und Zusammenf?gen von Zeilen

i <CR> trennt Zeile ab Cursorposition.

J f?gt folgende Zeile ans Ende der aktuellen Zeile an.

: set ts=n setzt den Tabulatorabstand auf n Zeichen

: set ai setzt die Option autoindent (Automatisches Ein-

r?cken).

<CTRL+D> geht zur n?chstkleineren Einr?ckung.

Ausf?hren von Shell Kommandos, Wiederholen und R?ckg?ngigmachen

: ! [cmd] verl?flt vi tempor?r und f?hrt das Kommando cmd aus

(ggf. R?ckkehr mit exit).

: r ! cmd f?gt die Ausgabe von cmd ab Cursorposition ein.

!! cmd benutzt aktuelle Zeile als Eingabe f?r cmd und ersetzt

durch dessen Ausgabe.

. wiederholt letztes Kommando

u macht letztes Kommando r?ckg?ngig.

- 13 -

vi - Erfassen und Bearbeiten von Textdateien

Anzeigen und ?ndern von Optionen

: set all zeigt alle gesetzten Optionen an.

: set opt = value setzt die Option opt auf den Wert value (siehe auch vi

Manual Page zu $HOME/.exrc).

- 14 -

make - Regelbasiertes Generieren von Programmen

6. make - Regelbasiertes Generieren von Programmen

In diesem Kapitel wird das make Kommando behandelt. make ist zusammen mit sccs bzw. rcs

das bekannteste und am h?ufigsten verwendete Werkzeug zur Verwaltung umfangreicher Soft-

ware-Projekte. Ausgehend von einer Beschreibung der Abh?ngigkeiten der Dateien ist make in

der Lage, automatisch alle Schritte durchzuf?hren, die zum ?bersetzen und Binden eines aus-

f?hrbaren Programmes notwendig sind.

Erstellen einer make Beschreibungsdatei

Ein typisches Projekt besteht aus mehreren Quelldateien mit der Endung .f (bzw. .f90, .c

oder .C) und ggf. weiteren Dateien wie Deklarationsdateien mit der Endung .h, sowie Parame-

terdateien, die spezielle Aspekte des Programmes "parametrisieren", und Eingabedateien mit

numerischen oder alphanumerischen Werten, z.B. Mefldaten..

Sie k?nnen z.B. ein C Programm automatisiert vom Kommando make erzeugen lassen. Hierzu

ben?tigen Sie eine make Beschreibungsdatei (Makefile), auch als Steuerdatei bezeichnet. Die

make Beschreibungsdatei benennt alle in einem Projekt verwendeten Dateien sowie die Regeln,

um aus ihnen eine Zieldatei (in der Regel ein ausf?hrbares Programm) bzw. mehrere

Zieldateien zu erzeugen.

Im folgenden wird ein einfaches Beispiel f?r eine make Beschreibungsdatei f?r 3 Quelldateien

pgm.c, func1.c, func2.c beschrieben, die Sie als Vorlage f?r eigene Projekte verwenden

und entsprechend erweitern k?nnen.

$ cat pgm.c

/* pgm.c */

... main(...) /* Program starts here ... */

{

... func1(...); /* and calls func1() ... */

... func2(...); /* and then func2() ... */

}

Die Zieldatei pgm setzt sich aus drei Objektdateien zusammen, die ihrerseits auf drei C Quellda-

teien beruhen. Die Quelldatei pgm.c enth?lt das Hauptprogramm main() und die Quelldateien

func1.c und func2.c enthalten die Funktionen func1() und func2(), die im Hauptprogramm

main() aufgerufen werden. Die Abh?ngigkeiten zwischen den Quelldateien und den

Zieldateien7 lassen sich folgendermaflen graphisch darstellen:

7 Der Begriff Quelldatei wird in diesem Kontext allgemein f?r eine Datei verwendet, die ?ber eine

Transformatione in eine Zieldatei verwandelt wird. In diesem Sinne ist z.B. func1.o eine der 3 Quelldateien f?r

pgm.

- 15 -

make - Regelbasiertes Generieren von Programmen

pgm.c func1.c func2.c

pgm.o func1.o func2.o

pgm

Sie m?ssen das Projekt mit den Abh?ngigkeiten zwischen den Datein in einer Makefile Datei8

beschreiben. Aus der Abbildung ist ersichtlich, dafl insgesamt 4 Transformationen notwendig

sind, um das ausf?hrbare Programm zu generieren. Ein Eintrag f?r eine Transformation hat

folgende allgemeine Form9:

target file: source file

<TAB>command to transform source file into target file

8 make verwendet per Voreinstellung sogenannte eingebaute Regeln oder Suffixregeln, die die oben genannten

Konventionen f?r Dateinamen voraussetzen, d.h. z.B. dafl C Quelldateien die Endung .c besitzen.

9 Der Tabulator in der 2. Zeile ist zwingend notwendig!

- 16 -

make - Regelbasiertes Generieren von Programmen

# Makefile

# calling sequence: make -f Makefile (or simply make)

# macro(s)

CC=xlc

CFLAGS=-O

# rule(s)

pgm: pgm.o func1.o func2.o

<TAB> $(CC) -o pgm pgm.o func1.o func2.o

func1.o: func1.c

<TAB> $(CC) $(CFLAGS) -c func1.c

func2.o: func2.c

<TAB> $(CC) $(CFLAGS) -c func2.c

pgm.: pgm.c

<TAB> $(CC) $(CFLAGS) -c pgm.c

Erzeugen des ausf?hrbaren Programmes

make f?hrt auf Grundlage der make Beschreibungsdatei alle notwendigen Schritte in der richti-

gen Reihenfolge durch.

Starten Sie make, wobei es per Voreinstellung die Datei Makefile im aktuellen Verzeichnis

verwendet und hierin die erste Zieldatei, hier das ausf?hrbare Programm pgm, generiert:

$ make # creates target pgm using the file Makefile as default.

xlc -O func1.c

xlc -O func2.c

xlc -O pgm.c

xlc -o pgm pgm.o func1.o func2.o

$ pgm # runs the executable program.

Der Vorteil von make besteht insbesondere darin, dafl es die Zeitstempel von Dateien auswer-

tet und deshalb bereits durchgef?hrte Transformationsschritte nicht unn?tig ein zweites Mal

ausf?hrt.

- 17 -

make - Regelbasiertes Generieren von Programmen

Ver?ndern Sie zum Beispiel nur die Quelldatei func2.c und beobachten Sie den Effekt:

$ vi func2.c

$ make

xlc -O func2.c # re-compilation.

xlc -o pgm pgm.o func1.o func2.o # linking.

In diesem Fall hat make nur die ge?nderte (!) Quelldatei neu ?bersetzt und danach das Pro-

gramm neu gebunden, d.h. es hat automatisch nur die unbedingt notwendige Aktionen ausge-

f?hrt.

- 18 -

xlc - ?bersetzen und Binden von C Programmen

7. xlc - ?bersetzen und Binden von C Programmen

In diesem Kapitel wird der IBM xlc C Compiler beschrieben.

?bersetzen, Binden und Starten

Sie k?nnen eine C Quelldatei sample1.c folgendermaflen am Bildschirm auflisten, ?bersetzen,

binden und starten:

$ cat sample1.c

#include <stdio.h>

int main(void)

{

printf("Hello World! ");

exit(0);

}

$ xlc -o sample1 sample1.c # compiles and links C source.

$ sample1 # runs program.

Hello World!

Auflisten der Optionen und Argumente

Sie k?nnen xlc folgendermaflen aufrufen, um am Bildschirm eine Kurzbeschreibung der voll-

st?ndigen Syntax angezeigt zu bekommen:

$ xlc

$ man xlc

Sie erhalten als Ausgabe dieser Kommandos eine Syntaxbeschreibung, die im folgenden be-

schr?nkt auf wichtige Optionen und Argumente wiedergegeben wird:

$ xlc [options] fn1 [fn2 ...]

Optionen:

-c ?bersetzt, ohne zu binden

-g erzeugt Debug-Information

-Iincdir definiert Suchpfad incdir f?r Header Files (#include "...")

-o exefile gibt ausf?hrbarem Programm den Namen exefile

- 19 -

xlc - ?bersetzen und Binden von C Programmen

-Llibdir definiert Suchpfad libdir f?r Bibliotheken

-lx durchsucht Bibliothek libx.a nach externen Referenzen

Argumente:

fn1, fn2, ... definiert Objektdateien fn1, fn2, ... (mit Endung .o)

bzw. definiert Quelldateien fn1, fn2, ... (mit Endung .c)

Erstellen einer make Beschreibungsdatei

Sie k?nnen ein C Programm automatisiert vom Kommando make erzeugen lassen. Hierzu be-

n?tigen Sie eine make Beschreibungsdatei (Makefile), die alle notwendigen Informationen f?r

make enthalten mufl.

Im folgenden wird ein Beispiel f?r eine make Beschreibungsdatei f?r 3 Quelldateien pgm.c,

func1.c, func2.c gezeigt, die Sie als Vorlage f?r eigene Projekte verwenden k?nnen.

$ cat Makefile

# Makefile

# macro(s)

CC=xlc

CFLAGS=-O

PGM=pgm

OBJS=func1.o func2.o

# rule(s)

.c.o:

$(CC) $(CFLAGS) -c $< # creates object from source.

# target(s), first target is default target

$(PGM): $(PGM).o $(OBJS)

$(CC) -o $(PGM) $(PGM).o $(OBJS) # creates executable.

Erzeugen Sie nun die gew?nschte Zieldatei (target), in diesem Fall das ausf?hrbare Programm

pgm, durch Aufruf von make:

$ make # creates target pgm using dependencies from Makefile.

$ pgm # runs the executable program.

- 20 -

xlf - ?bersetzen und Binden von Fortran Programmen

8. xlf - ?bersetzen und Binden von Fortran Programmen

In diesem Kapitel wird der IBM xlf Fortran Compiler beschrieben.

?bersetzen, Binden und Starten

Sie k?nnen die Quelldatei sample2.f folgendermaflen auflisten, ?bersetzen, binden und star-

ten:

$ cat sample2.f

program main

print *, "Hello World!"

end

$ xlf -o sample2 sample2.f

$ sample2

Hello World!

Auflisten der Optionen und Argumente

Sie k?nnen xlf folgendermaflen aufrufen, um am Bildschirm eine Kurzbeschreibung der voll-

st?ndigen Syntax angezeigt zu bekommen:

$ xlf

$ man xlf

Sie erhalten eine Syntaxbeschreibung, die im folgenden beschr?nkt auf wichtige Optionen und

Argumente wiedergegeben wird:

$ xlf [options] fn1 [fn2 ...]

Optionen:

-c ?bersetzt, ohne zu binden

-g erzeugt Debug-Information f?r

-Llibdir definiert Suchpfad libdir f?r Bibliotheken

-lx durchsucht Bibliothek libx.a nach externen Referenzen

-O[n] f?hrt Optimierung der Stufe n durch

-o exefile gibt ausf?hrbarem Programm den Namen exefile

-pg erzeugt Profiling Information

- 21 -

xlf - ?bersetzen und Binden von Fortran Programmen

Argumente:

fn1, .. definiert Quelldatei(en) fn1, ... (mit Endung .f)

bzw. definiert Objektdateien(en) fn1, ... (mit Endung .o)

Verwenden nicht-portabler xlf Erweiterungen

Der xlf Compiler unterst?tzt u.a. folgende Erweiterungen des genormten Fortran 77 Sprach-

umfangs, w?hrend der xlf90 Compiler den kompletten Fortran 90 Sprachumfang abdeckt:

? Quelltext kann im freien Eingabeformat eingegeben werden (Option -k).

? In Zeichenketten sind analog zu C folgende Symbole erlaubt:

, b, f, 0, ', ", \, x

? Die Zeichen '_' und '$' sind in Namen erlaubt.

? Namen d?rfen maximal 250 Zeichen lang sein.

? In der Anweisung ... ! comment leitet das Ausrufezeichen ! einen inline-Kommentar ein,

der bis zum Zeilenende reicht.

? Variablen k?nnen bereits bei der Definition mit einem Anfangswert versehen werden.

Erstellen einer make Beschreibungsdatei (Makefile)

Sie k?nnen ein Fortran Programm automatisiert vom Kommando make erzeugen lassen, um

Schreibarbeit zu vermeiden. Hierzu ben?tigen Sie eine make Beschreibungsdatei (Makefile),

die alle notwendigen Informationen f?r make enthalten mufl. Im folgenden wird ein Beispiel f?r

eine make Beschreibungsdatei gezeigt (siehe auch den entsprechenden Abschnitt bei xlc):

# Makefile

# command: make -f Makefile (or simply make)

# macro(s)

F77=xlf

FFLAGS=-O

# rule(s)

.f.o:

$(F77) $(FFLAGS) -c $<

# target(s)

$(PGM): $(PGM).o $(OBJS)

$(F77) -o $(PGM) $(OBJS) $(PGM).o

- 22 -

ar - Verwalten von Bibliotheken

9. ar - Verwalten von Bibliotheken

In diesem Kapitel wird der Bibliotheksverwalter ar vorgestellt, mit dem Sie Objektdateien in

einer Bibliothek zusammenfassen k?nnen. Insbesondere bei gr?fleren Projekten ist es ratsam,

inhaltlich zusammengeh?rige Funktionen in einer Bibliothek zu konzentrieren.

Erstellen einer Bibliothek

Der Bibliotheksverwalter ar faflt mehrere Objektdateien eines Projektes oder eines Anwen-

dungsgebietes (z.B. Graphik, Numerik, Systemfunktionen) zu einer Objektbibliothek (oder

kurz Bibliothek) zusammen.

Geben Sie folgendes Kommando ein, um eine neue Objektbibliothek librng.a zu erzeugen,

die die Objektdateien random1.o, random2.o und random3.o enthalten soll:

$ ar vq librng.a random1.o random2.o random3.o

ar: Creating an archive file librng.a.

q - random1.o

q - random2.o

q - random3.o

Die folgenden Kommandos sind nun ?quivalent, da die Bibliothek librng.a die Objektdateien

random1.o bis random3.o enth?lt:

# Using 3 object files ...

$ xlc -o sample1 sample1.c random1.o random2.o random3.o

# Using 1 library file ...

$ xlc -o sample1 sample1.c librng.a

Auflisten wichtiger Optionen und Argumente

Sie k?nnen die Arbeitsweise von ar u.a. ?ber folgende Optionen und Argumente steuern:

ar [options] library objs

$ ar -tv libfile.a # lists table of contents.

$ ar -uv libfile.a file(s).o # updates file(s) in lib.

$ ar -dv libfile.a file(s).o # deletes file(s) in lib.

- 23 -

dbx, gprof - Suchen von Fehlern und Messen von Programmen

10. dbx, gprof - Suchen von Fehlern und Messen von Programmen

In diesem Kapitel werden der symbolische Debugger dbx, das Meflprogramm timex und das

Analyseprogramm gprof vorgestellt.

Weitere Werkzeuge zur Analyse von Programmen sind z.B. ftnchek, vast90 und lint

(syntaktische und semantische Analyse) sowie die Funktionen gettimer (f?r C) und MCLOCK

(f?r Fortran) zur Zeitmessung.

Durchf?hren einer Debug-Sitzung

?bersetzen Sie zun?chst alle Quelldateien mit der Option -g. Der Compiler f?gt aufgrund die-

ser Option in allen Objektdateien zus?tzliche Informationen hinzu, die f?r die sp?tere Ausf?h-

rung unter Kontrolle des symbolischen Debuggers dbx ben?tigt werden10 (?nderungen im

Makefile: CFLAGS=-g, FFLAGS=-g):

cat div_by_zero.f

program DivisionByZero

double precision x

x=0.0D0

print *, "Sinus(x)/x fuer x=0: ", sin(x)/x

print *, "1/0: ", 1.0/x

end

$ xlf -g -qflttrap -o div_by_zero div_by_zero.f

Sie k?nnen nun das Programm unter Kontrolle von dbx ablaufen lassen. Die Eingabeaufforde-

rung innerhalb einer dbx Sitzung ist (dbx):

$ dbx div_by_zero

(dbx) help # lists available dbx commands.

10 Dieses "Aufbl?hen" mit zus?tzlichen Informationen verlangsamt die Programmausf?hrung. Ihre endg?ltige

Version (release version) sollte deshalb mit der Option -O ?bersetzt werden.

- 24 -

dbx, gprof - Suchen von Fehlern und Messen von Programmen

run - begin execution of the program

print <exp> - print the value of the expression

where - print currently active procedures

stop at <line> - suspend execution at the line

stop in <proc> - suspend execution when <proc> is called

cont - continue execution

step - single step one line

next - step to next line (skip over calls)

trace <line#> - trace execution of the line

trace <proc> - trace calls to the procedure

trace <var> - trace changes to the variable

trace <exp> at <line#> - print <exp> when <line> is reached

status - print trace/stop's in effect

delete <number> - remove trace or stop of given number

screen - switch dbx to another virtual terminal

call <proc> - call a procedure in program

whatis <name> - print the declaration of the name

list <line>, <line> - list source lines

registers - display register set

quit - exit dbx

(dbx) run # starts program execution.

(dbx) ...

(dbx) quit # terminates dbx session.

Die prim?re Aufgabe von dbx ist die Unterst?tzung bei der Fehlersuche, z.B. bei der Suche

nach einer Floating Point Exception wie Division durch Null oder nach einem Zeiger-Fehler,

die jeweils einen Programmabsturz (core dump) verursachen.

Durchf?hren einer Zeitmessung

Starten Sie das Programm sample1 unter Kontrolle von timex:

$ timex sample1 2> sample1.timing > sample1.stdout

Nach der Ausf?hrung enth?lt die Datei sample1.timing folgende Zeitmessungen:

real 0.06 # turn-around time (time to wait)

# = time for loading, executing and exiting

user 0.01 # time spent in user code

sys 0.02 # time spent for system calls

# real - user -sys = other pgms running

- 25 -

dbx, gprof - Suchen von Fehlern und Messen von Programmen

Durchf?hren einer Laufzeitanalyse

?bersetzen Sie alle Quelldateien mit der Option -pg, um Informationen f?r gprof zu erzeugen

(CFLAGS=-pg, FFLAGS=-pg):

$ xlc -pg -o sample1 sample1.c

F?hren Sie nun das Programm sample1 aus, wobei automatisch eine zus?tzliche Datei

gmon.out erzeugt wird:

$ sample1 # creates profiling info in gmon.out.

Das Programm erzeugt automatisch im aktuellen Verzeichnis eine Datei gmon.out mit Lauf-

zeitinformationen, die Sie im Anschlufl mit gprof aufbereiten k?nnen11:

elm

$ gprof > sample1.gprof # creates well-documented profile

# file, named: sample1.gprof

$ vi sample1.gprof

Die von gprof erzeugte Datei sample1.gprof enh?lt in verschiedenen Abschnitten Informa-

tionen ?ber das Laufzeitverhalten von sample1. F?r den ersten ?berblick ist das flache Profil

(flat profile) n?tzlich, in dem die vom Programm verwendeten Funktionen nach H?ufigkeit

sortiert aufgelistet werden. Andere Abschnitte gehen detailliert auf die Eltern-Kind-Beziehung

von Funktionen ein, d.h. sie erl?utern, welche Funktion (caller oder parent) andere Funktionen

(child oder callee) mit einer bestimmten H?ufigkeit aufgerufen hat.

Auf Grundlage dieser Informationen k?nnen Sie die Kernfunktionen Ihres Programmes (Hot

Spots) herausfinden und ggf. an diesen Stellen Optimierungen vornehmen.

11 Beachten Sie beim Profiling immer den Unterschied zwischen der H?ufigkeit (Wie h?ufig wurde eine

Funktion aufgerufen?) und der Verweilzeit (Wie lange verweilte das Programm innerhalb einer Funktion?). Die

heiflen Stellen eines Programmes (Hot Spots) sind Funktionen mit einer hohen relativen Verweilzeit.

- 26 -

co - Verwalten von unterschiedlichen Programmversionen

11. co - Verwalten von unterschiedlichen Programmversionen

In diesem Kapitel wird das Revision Control System, kurz RCS, behandelt. RCS ist ein Sy-

stem zur Versionskontrolle von Textquellen aller Art.

Ein- und Auschecken

Die wesentlichen RCS Kommandos sind ci und co, zum Check In bzw. Check Out einer Ar-

beitsdatei:

1. Das ci Kommando speichert einen Text xyz mit allen durchgef?hrten ?nderungen und

zus?tzlichen Informationen (z.B. Datum jeder ?nderung, Autor, Grund der ?nderung) in

einer neuen bzw. aktualisierten RCS Datei xyz,v.

2. Auf Grundlage der RCS Datei kann das zu ci komplement?re Kommando co z.B. jede be-

liebige Version des Textes oder ein Protokoll aller durchgef?hrten ?nderungen aus xyz,v

erzeugen. Dies ist vor allem bei Quelltextdateien hilfreich, wenn eine neue Version nicht

stabil ist und deshalb die Vorg?ngerversion rekonstruiert werden soll.

Als Beispiel dient folgendes (einfache und zudem fehlerhafte) C-Programm hellow.c:

/* $Header$ */

/* $Log$ */

int main (void)

{

static char chRCS_Id[]="$Id$"12;

printf("Hello World! ");

exit(0);

}

?bergeben Sie die Quelltextdatei in die Kontrolle des Revision Control Systems:

$ setup rcs # sets environment

$ ci hellow.c # checks in hellow.c into RCS file hellow.c,v.

Das ci Kommando fragt zun?chst interaktiv nach einer Kurzbeschreibung der Datei hellow.c

(hier z.B.: This is a simple "Hello World" Program.) und erzeugt dann eine RCS Datei

mit Endung ,v, hier: hellow.c,v, mit allen notwendigen Informationen. Als erste Ver-

sionsnummer wird von ci automatisch die Nummer 1.1 (Initial Revision) vergeben.

12 Beachten Sie die fett ausgezeichnete Zeile, in der das RCS Schl?sselwort $Id$ enthalten ist.

- 27 -

co - Verwalten von unterschiedlichen Programmversionen

Nun k?nnen Sie bei Bedarf mit dem Kommando co eine Arbeitsdatei der Version 1.1 zur wei-

teren Bearbeitung "auschecken", wobei die Option -l die RCS Datei gegen erneutes

"Auschecken" sch?tzt:

$ co -l hellow.c # checks out latest version for editing (with lock)

Das co Kommando sucht die RCS Datei hellow.c,v, und extrahiert die letzte Version als

Arbeitsdatei hellow.c. Dabei expandiert co die Schl?sselw?rter $Header$ (oder k?rzer $Id$)

und $Log$ automatisch mit den aktuellen Werten, hier z.B. der Eintrag f?r $Id$:

$Id: hellow.c,v 1.1 1994/01/18 12:40:34 elsner Exp $

a) b) c) d) e)

Die Zeile beinhaltet (a) den Namen der RCS Datei, (b) die Versionsnummer, (c) Datum und

Zeit der letzten ?nderung, (d)den Autor und (e) den Status, Exp f?r Experimental.

F?gen Sie zus?tzlich eine Zeile der Form /* $Log$ */ und eine Zeile mit der #include

<stdio.h> Direktive hinzu und ?bergeben Sie die modifizierte Arbeitsdatei wieder an RCS:

$ ci hellow.c # checks in for the second time.

Das ci Kommando fragt nun interaktiv nach einer Kurzbeschreibung der vorgenommenen

?nderungen (hier z.B.: Added #include <stdio.h>.) und f?gt dann die ?nderungen in die

Datei hellow.c,v ein. Die Versionsnummer wird von ci automatisch erh?ht, lautet nun also

1.2.

Anzeigen des Protokolls aller ?nderungen

Das rlog Kommando gibt einen zusammenfassenden ?berblick ?ber die RCS Datei hel-

low.c, v und alle vorgenommenen ?nderungen (Log Messages):

RCS file: hellow.c,v

...

description:

This is a simple "Hello World" program.

----------------------------

- 28 -

co - Verwalten von unterschiedlichen Programmversionen

revision 1.2

date:1994/01/18 12:41:52;

author: elsner; state: Exp; lines: +2 -2

Added #include <stdio.h>.

----------------------------

revision 1.1

date: 1994/01/18 12:40:34;

author: elsner; state: Exp;

Initial revision

Das ident Kommando sucht in jeder beliebigen Datei, also auch in einer Datei vom Typ

Executable, nach RCS Schl?sselw?rtern der Form $Id:<any text>$. Mit Hilfe von ident

k?nnen Sie also jederzeit feststellen, aus welchen Versionen von Programmquellen ein Pro-

gramm zusammengesetzt ist:

$ ident hellow # checks hellow for RCS keywords.

$Id: hellow.c,v 1.1 1994/01/18 12:40:34 elsner Exp $

Verwenden einer make Beschreibungsdatei

Ein kleiner Wermutstropfen ist die mangelhafte Zusammenarbeit von make unter AIX mit

RCS. make kennt keine vordefinierten Suffixregeln f?r RCS Dateien.

Erg?nzen Sie folgendermaflen Regeln f?r C und Fortran Programme in make Beschreibungs-

dateien (Makefiles):

CO=co

F77=xlf

RM=rm

.SUFFIXES: .f,v .c,v

.f,v:

<TAB> (${CO} $*.f; (F77) $(FFLAGS) -o $* $*.f; $(RM) -f $*.f)

.f,v.o:

<TAB> (${CO} $*.f; $(F77) $(FFLAGS) -c $*.f; $(RM) -f $*.f)

...

# <Your project description>

...

- 29 -

?berblick ?ber Standardbibliotheken

12. ?berblick ?ber Standardbibliotheken

In diesem Kapitel werden die C und Fortran Laufzeitbibliothek vorgestellt und es erfolgen

Hinweise auf weitere Standardbliotheken.

Verwenden von Standardbibliotheken

Viele Probleme lassen sich in Teilprobleme zerlegen, f?r die bereits Funktionen in Standard-

bibliotheken zur Verf?gung stehen. Falls nicht besondere Gr?nde f?r die Entwicklung eigener

Funktionen sprechen, sollten Funktionen aus Standardbibliotheken verwendet werden.

Folgende Standardbibliotheken stehen u.a. zur Verf?gung13:

ll libc.a - Standard Bibliothek f?r C

l libxlf.a - Standard Bibliothek f?r Fortran

l libm.a - Standard Mathematik Bibliothek f?r C und Fortran

Zordnen der verf?gbaren Dateien

Die folgende Tabelle enth?lt Bibliotheken, ihre Dateinamen und, falls vorhanden, die zugeh?ri-

gen C Deklarationsdateien (C header files):

Bibliothek Datei Zugeh?rige Deklarationen

Standard Bibliothek f?r C /usr/lib/libc.a /usr/include/stdio.h

...

(siehe: /usr/include)

Standard Bibliothek f?r

Fortran

/usr/lib/libxlf.a -

Standard Mathematik Biblio-

thek f?r C und Fortran

/usr/lib/libm.a /usr/include/math.h

/usr/include/errno.h

13 Die Aufz?hlung gilt speziell f?r das RS/6000 Cluster des Rechenzentrums. Erkundigen Sie sich ggf. bei

Ihrem Systemverwalter, welche Bibliotheken installiert sind oder konsultieren Sie das Verzeichnis /usr/lib und

die Handb?cher Ihres UNIX Systems.

- 30 -

?berblick ?ber numerische Bibliotheken

13. ?berblick ?ber numerische Bibliotheken

In diesem Kapitel werden einige wichtige numerische Bibliotheken vorgestellt.

Verwenden von numerischen Bibliotheken

Viele numerische Probleme lassen sich auf elementare numerische Verfahren zur?ckf?hren.

Falls nicht besondere Gr?nde f?r die Entwicklung eigener Prozeduren sprechen, sollten Proze-

duren aus kommerziellen Bibliotheken verwendet werden.

Folgende numerischen Bibliotheken stehen u.a. zur Verf?gung14:

? libm.a - Standard Mathematik Bibliothek f?r C und Fortran

? libblas.a - Basic Linear Subroutine Library (BLAS)

? libessl.a - IBM Engineering and Scientific Subroutine Library

? libnagf.a - NAG Fortran Library

? libosl.a - IBM Optimization Subroutine Library

Zordnen der verf?gbaren Dateien

Die folgende Tabelle enth?lt f?r einige Bibliotheken die Bezeichnungn, den Dateinamen und,

falls vorhanden, die zugeh?rigen C Deklarationsdateien (C header files) auf:

14 Die Aufz?hlung gilt speziell f?r das RS/6000 Cluster des Rechenzentrums. Erkundigen Sie sich ggf. bei

Ihrem Systemverwalter, welche numerischen Bibliotheken installiert sind.

- 31 -

?berblick ?ber numerische Bibliotheken

Bibliothek Datei Zugeh?rige Deklarationen

Standard Mathematik Biblio-

thek f?r C und Fortran

/usr/lib/libm.a /usr/include/math.h

/usr/include/errno.h

Basic Linear Subroutine Libr-

ary

/usr/lib/libblas.a -

IBM Engineering and

Scientific Subroutine Library

/usr/lib/libessl.a /usr/include/essl.h

NAG Fortran Library /usr/local/lib/libnagf.a /usr/local/include/

nagf.h

Das Einbinden von C Deklarationsdateien erfolgt in der ?bersetzungsphase, wobei eine ent-

sprechende #include Direktive in der Quelldatei notwendig ist. Das Einbinden von Bibliothe-

ken erfolgt sowohl f?r C als auch f?r Fortran w?hrend der Bindephase, also typischerweise in

der folgenden Form15:

$ xlc -o pgm pgm.o /usr/lib/libm.a

# links pgm.o using external functions from libm.a.

F?r Bibliotheken, deren Dateinamen die Form libXXX.a haben, gibt es zur Vermeidung von

Schreibarbeit eine Compiler-Option -lXXX:

$ xlc -o pgm pgm.o -L/usr/lib -lm

# links pgm.o using external functions from libm.a.

Verwenden von Computeralgebrasystemen

Ferner stehen folgende Computeralgebrasysteme zur Verf?gung, mit denen sich auch numeri-

sche Probleme bearbeiten lassen:

? Maple

? Mathematica

15 Die meisten Compiler kennen die Optionen -Llibpath und -lXXX. Die Option -l setzt voraus, dafl die

Bibliothek den Namen libXXX.a besitzt.

- 32 -

?berblick ?ber numerische Bibliotheken

Interessant sind hierbei insbesondere folgende M?glichkeiten im Bereich der Numerik:

? Durchf?hren von numerischen Berechnungen mit beliebiger Genauigkeit

? Erzeugen von optimierten C und Fortran Code

? Einfaches Zugreifen auf umfangreiche Bibliotheken math. Funktionen und Verfahren

- 33 -

?berblick ?ber Graphik-Bibliotheken und -Programme

14. ?berblick ?ber Graphik-Bibliotheken und -Programme

In diesem Kapitel wird ein kurzer ?berblick ?ber Graphik-Bibliotheken und -Programme ge-

geben, mit denen numerische Ergebnisse visualisiert werden k?nnen. Ferner werden die m?gli-

chen Ausgabeger?te aufgelistet.

Verwenden von Graphik-Bibliotheken und -Programmen

Folgende Graphik-Bibliotheken und -Programme stehen zur Verf?gung:

Produkt Kurzbeschreibung Aufruf

GNU gnuplot setup gnuplot

man gnuplot

setup gnuplot

gnuplot

IBM Data Explorer setup data_explorer

man dx

setup data_explorer

dx # needs X

NAG Graphics Library setup nag_help

naghelp

setup nag_graphics

xlf -L/usr/local/lib

-lnagg -o pgm ...

Maple

(enth?lt integrierte Graphik)

setup maple

man maple

setup maple

[x]maple

Mathematica

(enth?lt integrierte Graphik)

setup mathematica

man math

setup mathematica

math

POV-RAY Raytracer setup raytracer

povray

setup raytracer

povray options

XFIG setup xfig

setup -i xfig

setup xfig

xfig

Drucken und Plotten

Sie k?nnen mit dem lpr Kommando eine Datei mit Graphikinformationen auf einem Drucker

bzw. Plotter ausgeben:

$ lpr -Pqn fn # prints file fn to printer queue qn

Zum Beispiel wird eine PostScript Datei sample.ps mit folgendem Kommando auf dem HP

Laserjet III SI (PostScript) des RZ gedruckt:

- 34 -

?berblick ?ber Graphik-Bibliotheken und -Programme

$ lpr -Pps2rz sample.ps

Folgende Drucker und Plotter stehen zur Verf?gung16:

Name (queue) Typbezeichnung Format

lprz IBM 6262 ASCII

pcl2rz HP Laserjet III Si PCL 5, DIN A4

pcl1rz HP DeskJet 500 C PCL, DIN A4

pl1rz IBM 6186 DIN A0 Plotter HPGL

ps1rz Apple Laserwriter II NTX PostScript, DIN A4

ps2rz HP Laserjet III Si PostScript PostScript, DIN A4

ps2rzdp HP Laserjet III Si PostScript,

doppelseitiger Druck

PostScript, DIN A4

Eine Ausnahme bildet der elektrostatische Plotter VERSATEC CE3425E. Hier ist eine

Kombination der Kommandos vsplot und lpr vorgesehen. Erzeugen Sie zun?chst eine

Plotdatei fn im PPM17 Format (siehe z.B. man xv). Konvertieren Sie die Datei mit dem

Kommando vsplot in das Versatec Format und plotten Sie im Anschlufl mit lpr:

$ vsplot fn | lpr -Ppunrz

Ausgaben k?nnen im AVZ, Untergeschofl, Raum B20, abgeholt werden.

16 Stand zum Zeitpunkt der Drucklegung.

17 Die Portable Bitmap Tools (PBM) bestehen aus Werkzeugen, um u.a. diverse Graphikformate wie z.B. GIF,

TIFF, Targa ?ber ein universelles Austauschformat PPM ineinander umzuwandeln.

- 35 -

Anhang

make Beschreibungs- oder Steuerdatei (Makefile)

#--------------------------------------------------------------------#

# Makefile template for C and Fortran programming

# Calling sequence: make -f Makefile or simply make

#--------------------------------------------------------------------#

# Macros:

#--------------------------------------------------------------------#

# Linker flags

LFLAGS=-L/usr/local/lib -lm -lxlf -lblas -lnagf

# Fortran Compiler

F77=xlf

# Full profiling and debugging

FDEBUG=-pg

# Full optimization

FOPTIMIZE=-O3

# Compiler Flags, either FDEBUG or FOPTIMIZE

FFLAGS=$(FDEBUG)

# C Compiler

CC=xlc

# Full debugging and profiling

CDEBUG=-pg

# Full optimization

COPTIMIZE=-O

# Compiler Flags, either CDEBUG or COPTIMIZE

CFLAGS=$(CDEBUG)

#--------------------------------------------------------------------#

# Suffix rules:

#--------------------------------------------------------------------#

.f.o:

$(F77) $(FFLAGS) -c $<

.f:

$(F77) -o $@ $(FFLAGS) $(LFLAGS) $<

.c.o:

$(CC) $(CFLAGS) -c $<

.c:

$(CC) -o $@ $(CFLAGS) $(LFLAGS) $<

#--------------------------------------------------------------------#

# Project specific rules:

# Substitute appropriate values for your project!

#--------------------------------------------------------------------#

PGM=sample1

OBJS=func1.o func2.o

LIBS= ./libll.a ./libhelp.a

$(PGM): $(PGM).o $(LIBS) $OBJS) Makefile

$(CC) -o $(PGM) $(LDFLAGS) $(PGM).o $(OBJS) $(LIBS)

- 36 -