Beispielprogramme:

Alignment, Kind-Prozesse, Threads, Graphische Bedienoberfläche mit X Window, Signal-Behandlung, Pipes, Semaphore und Shared Memory

Beispiele:

Alignment

Kind-Prozess starten

Programm starten

Exit-Status

Thread

Graph. Bedienoberfläche

Signal-Behandlung

Pipe

Semaphor

Shared Memory

Die hier aufgeführten Programm-Beispiele gehören zur Vorlesung "Rechnerorganisation" an der Berufsakademie Stuttgart. Sie zeigen das Verhalten und die Anwendung einiger Systemfunktionen.

Die Beispiele wurden unter Linux erstellt, sollten aber auf allen POSIX-konformen Systemen übersetzt und ausgeführt werden können. Für das Programm gui_bsp sind außerdem Header- und Bibliotheks-Dateien für X11 und OSF/Motif notwendig.

Die Quelldateien aller Beispiele und das Makefile sind zusammen als zip-Datei (ca. 50 KB) verfügbar.

Übersetzen aller Programme:   make

Alignment: Ausrichtung von Variablen im Speicher

Variante 1: Wirkung von fork()

Das Programm align_bsp zeigt, wie Variablen im Arbeitsspeicher ausgerichtet sind:

Das Programm verwendet dazu eine Datenstruktur mit Elementen unterschiedlicher Datentypen. In mehreren Schritten zeigt das Programm zunächst die Größe der einzelnen Elemente der Datenstruktur, die Gesamtgröße der Datenstruktur und die Anfangs-Adressen der Elemente an.

Die Ausrichtung der Elemente der Datenstruktur - und damit die Ausgabe des Programms - kann je nach CPU-Familie und / oder Betriebssystem unterschiedlich sein.

zum Seitenanfang

Kind-Prozess starten

Variante 1: Wirkung von fork()

Das Programm fork_simple zeigt das Erzeugen eines Kind-Prozesses mit fork():

Durch den Aufruf der Funktion fork() wird ein neuer Prozess erzeugt. Dieser Kind-Prozess ist immer eine 1:1-Kopie des Eltern-Prozesses zum Zeitpunkt des Aufrufs der Funktion fork(). Nach dem Rücksprung aus der Funktion fork() laufen Eltern- und Kind-Prozess voneinander unabhängig weiter.

In diesem Beispiel führen Eltern- und Kind-Prozess nach der Funktion fork() den gleichen Programmcode aus, d. h. alle Befehle nach fork() werden je einmal vom Eltern- und vom Kind-Prozess ausgeführt. Die Ausgabe "... Ergebnis von fork() ..." erscheint deshalb zweimal, jedoch mit unterschiedlichen Werten für die Prozess-ID und für das Ergebnis von fork().

In der Praxis sollen Eltern- und Kind-Prozess jedoch unterschiedliche Aufgaben ausführen, wie z. B. in der folgenden Variante 2.

zum Seitenanfang

Variante 2: Ausführen unterschiedlicher Programmteile in Eltern- und Kind-Prozess

Das Programm childproc zeigt ebenfalls das Erzeugen eines Kind-Prozesses mit fork(). In diesem Beispiel führen Eltern- und Kind-Prozess jedoch zum Teil unterschiedliche Befehle aus. Außerdem wird in diesem Beispiel der Inhalt von Variablen beobachtet um zu zeigen, dass beim Aufruf von fork() alle Variablen und deren Inhalte vom Eltern-Prozess in den Kind-Prozess kopiert werden, die Variablen der beiden Prozesse aber danach voneinander unabhängig sind.

zum Seitenanfang

Programm in separatem Prozess starten

Dieses Beispiel zeigt das Ausführen eines anderen Programms in einem separaten Prozess:

Das Programm startprog spaltet zunächst mit fork() einen Kind-Prozess ab. Danach wird in dem Kind-Prozess durch Aufrufen von execl() das Programm progbsp ausgeführt.

Die Argumente, mit denen startprog aufgerufen wird, werden vom Programm zu Demonstrationszwecken angezeigt, haben aber keinen Einfluss auf den Programmablauf.

zum Seitenanfang

Übergabe des Exit-Status vom Kind- zum Eltern-Prozess

Dieses Beispiel zeigt die Übergabe des Exit-Status vom Kind- an den Eltern-Prozess und dessen Auswertung im Eltern-Prozess:

Der Eltern-Prozess startet mit fork() für jedes in der Befehlszeile übergebene numerische Argument einen Kind-Prozess, der sich nach einer zufälligen individuellen Wartezeit mit exit() beendet. Dabei wird der als Argument übergebenen Exit-Status übergeben.

Nachdem der Eltern-Prozess alle Kind-Prozesse erzeugt hat, wartet er auf das Ende der Kind-Prozesse, fragt mit wait() deren Exit-Status ab und zeigt ihn mit der Prozess-ID des betreffenden Kind-Prozess-ID an.

zum Seitenanfang

Funktion in separatem Thread ausführen

Das Programm pthread startet mit pthread_create() eine Funktion in einem separaten Thread. Jeder Thread schreibt Adresse und Inhalt einiger Variablen auf den Bildschirm. Diese Informationen zeigen, dass

• die als Thread gestartete Funktion und die von dort aus aufgerufenen Funktionen einen separaten Register-Satz und einen eigenen Stack verwenden, aber
• beide Threads gemeinsam auf die globalen Variablen und den Stack bis zu der Funktion, die den Thread gestartet hat, zugreifen.

zum Seitenanfang

Graphische Bedienoberfläche mit X Window und OSF/Motif

Der Quellcode   gui_bsp.c   des Programms zeigt die typische Programmstruktur eines Programms mit graphischer Bedienoberfläche mit der daraus resultierenden Ereignis-orientierten Steuerung des Programmablaufs: Das Betätigen von Buttons veranlasst die Ereignis-Behandlung, die Callback-Funktion aufzurufen, die für den betreffenden Button registriert ist.

Das Programm erzeugt ein Fenster mit einer Text-Anzeige und Buttons. Über die Buttons können wahlweise weitere Fenster erzeugt, oder das Programm beendet werden.

zum Seitenanfang

Signal-Behandlung entsprechend POSIX.1 = IEEE 1003.1-1990

Das Programm sig_posix zeigt die Signal-Behandlung des Signals SIGTERM durch eine eigene Signalbehandlungs-Funktion:

Nach dem Aktivieren der neuen Signal-Behandlung für SIGTERM schreibt das Programm seine eigene Prozess-ID auf den Bildschirm. Wenn der Prozess das Signal SIGTERM erhält, wird der Prozess nicht beendet, sondern die Anzahl der empfangenen Signale hochgezählt. Das Programm zeigt den Zählerstand periodisch auf dem Bildschirm an und endet, wenn ein im Programm vorgegebener Zählerstand erreicht ist.

Unter UNIX, Windows-NT, Windows-XP usw. kann der Befehl

       kill Prozess-ID

verwendet werden, um ein SIGTERM an den Prozess mit der betreffenden Prozess-ID zu senden.

zum Seitenanfang

Datentransfer über eine Pipe vom Kind- zum Eltern-Prozess

Das Programm pipe zeigt ein Beispiel für den Datentransfer vom Kind- zum Eltern-Prozess über eine Pipe.

Dazu wird zunächst mit pipe() eine Pipe angelegt. Anschließend wird mit fork() ein Kind-Prozess erzeugt, der damit auch die Lese- und Schreib-Deskriptoren der Pipe erbt. Nachdem Eltern- und Kind-Prozess jeweils den von ihnen nicht benötigten Deskriptor geschlossen haben, sendet der Kind-Prozess Daten an den Eltern-Prozess. Der Eltern-Prozess zeigt die empfangenen Daten auf dem Bildschirm an.

zum Seitenanfang

Interprozess-Kommunikation über ein Semaphor

Das Programm sem_demo zeigt die Kommunikation zwischen Prozessen über ein Semaphor: Nach dem Start wird ein Semaphor zu dem als Programm-Argument angegebenen Semaphor-Key angelegt und initialisiert, sofern das Semaphor noch nicht existiert. Danach wartet das Programm auf Befehle, mit denen der Semaphor-Zustand verändert oder abgefragt werden kann.

Damit das Verhalten der Semaphor-Funktionen des Betriebssystems direkt gezeigt wird, führt das Programm die eingegebenen Befehle ohne Plausibilitätskontrolle aus!

Um die Kommunikation zwischen verschiedenen Prozessen auszuprobieren, muss das Programm gleichzeitig in mehreren Prozessen laufen. Starten und betreiben Sie das Programm dazu parallel in mehreren Kommandozeilen-Fenstern und verwenden Sie dabei jeweils die selbe positive ganze Zahl als Argument für den Semaphor-Key, z. B. 23 (willkürlich gewählt). Der verwendete Zahlenwert ist dabei innerhalb erlaubten des Wertebereichs beliebig.

Sie können natürlich auch parallel dazu weitere Prozesse mit anderen Semaphoren betreiben, z. B.

• 4 (oder n) Prozesse mit Semaphor-Key 23 und
• 3 (oder m) Prozesse mit Semaphor-Key 29

Die genannte Anzahl der Prozesse und die Werte für die Semaphor-Keys wurden ebenfalls willkürlich gewählt.

zum Seitenanfang

Datentransfer über ein Shared Memory

Die Programme shm_send und shm_recv zeigen ein Beispiel für den Datentransfer zwischen Prozessen mit Hilfe eines Shared Memory:

shm_send legt für den übergebenen Shared-Memory-Key zunächst ein Shared Memory an, sofern es noch nicht existiert. Danach verbindet sich der Prozess mit dem Shared Memory und schreibt seine eigene Prozess-ID sowie einen Text mit Datum und Uhrzeit in das Shared Memory.

Bei jeder Betätigung der Enter-Taste wird eine neue Meldung mit der eigenen Prozess-ID und aktuellem Datum und Uhrzeit in das Shared Memory geschrieben. Die geschriebene Meldung wird jeweils auf dem Bildschirm angezeigt.

shm_recv verbindet sich ebenfalls mit dem Shared Memory, das zum angegebenen Shared-Memory-Key gehört. Danach liest das Programm den aktuellen Inhalt des Shared Memory gelesen und angezeigt.

Bei jeder Betätigung der Enter-Taste wird der aktuelle Inhalt des Shared Memory erneut gelesen und angezeigt.

shm_send und shm_recv sollen in unterschiedlichen Kommandozeilen-Fenstern gestartet werden. Die Programme können auch mehrfach parallel in verschiedenen Fenstern laufen.

Alle Programme, die den selben Shared-Memory-Key verwenden, arbeiten mit dem selben Shared Memory. Der Shared Memory Key ist - analog zum Semaphor-Key - eine positive ganze Zahl, die innerhalb des erlaubten Wertebereichs frei wählbar ist.

zum Seitenanfang