Hinweise

• Am Mittwoch, 18.11., um 18.00 Uhr s.t. findet die schriftliche Zwischenklausur im Raum C 123 in der Theresienstraße statt.
• In der Vorlesung am Donnerstag, 19.11., erfolgt die Einteilung der Programmierteams. Es besteht also Anwesenheitspflicht. An diesem Termin findet kein Kurztest statt.

Theoretische Aufgaben (Blatt 3)

Aufgabe T-3-1

Aufgabe T-3-2

1. Was ist ein Zombie-Prozess, und wie kann er entstehen?
2. Wann spricht man im Kontext von Prozessen von einem Waisen? Was geschieht mit ihm, wenn er entstanden ist?
3. Analysieren Sie die folgenden vier Programme. Erklären Sie die Unterschiede, und beschreiben Sie die Folgen daraus. Finden Sie heraus, wo ein Zombie und wo ein Waise deutlich sichtbar wird. Überprüfen Sie Ihre Vermutungen durch Übersetzen und Testen der Programme! Hierbei hilft Ihnen ein mehrfaches ps l | grep < progname > in einem anderen Fenster. Dokumentieren Sie Ihre Ergebnisse ausführlich!
4. Beantworten Sie die folgenden Fragen zu den einzelnen Programmen:
   1. Zu Programm A: Was geschieht in Zeile 27 ( kill(childPID, SIGINT); ) genau? Gibt es einen Zusammenhang mit der Entstehung oder Vermeidung von Zombies und/oder Waisen?
   2. Zu Programm B: Inwiefern tragen die Zeilen 17 und 25 ( sleep() -Aufrufe) zum Entstehen von Zombies und/oder Waisen bei?
   3. Zu Programm C: Was geschieht in Zeile 23 ( wait(&status); ) genau? Gehen Sie insbesondere auf die Bedeutung der Variablen status ein. Informationen hierzu finden Sie in der Manpage der Funktion wait() .

        
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char* argv[]) {
  pid_t childPID;
  int a;

  childPID = fork();
   
  if (childPID == 0 ) {
    for(a=0; a<10; a++) {
      printf("for loop: child PID %d, %i \n", getpid(), a);
      sleep(2);
    }
    printf("child done: child PID %d \n", getpid());
    exit(0);
  }

  for(a=0; a<10; a++) {
    printf( "\t\t\t\t parent: child PID %d, %i\n", childPID, a);
    sleep(1);
  }
  kill(childPID, SIGINT);
  printf("\t\t\t\t parent done: child PID %d, %i\n", childPID, a);
  exit(0);
}

    
      

        
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char* argv[]) {
  pid_t childPID;
  int a;

  childPID = fork();
   
  if(childPID == 0) {
    for(a=0; a<10; a++) {
      printf("for loop: child PID %d, %i \n", getpid(), a);
      sleep(1);
    }
    printf("child done: child PID %d \n", getpid());
    exit(0);
  }

  for(a=0; a<10; a++) {
    printf("\t\t\t\t parent: child PID %d, %i\n", childPID, a);
    sleep(2);
  }
  printf("\t\t\t\t parent done: child PID %d, %i\n", childPID, a);
  exit(0);
}

    
      

        
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char* argv[]) {
  pid_t childPID;
  int a, status;

  childPID = fork();
   
  if (childPID == 0 ) {
    for(a=0; a<10; a++) {
      printf("for loop: child PID %d, %i \n", getpid(), a);
      sleep(2);
    }
    printf("child done: child PID %d \n", getpid());
    exit(0);
  }

  wait(&status);
  for(a=0; a<10; a++) {
    printf("\t\t\t\t parent: child PID %d, %i\n", childPID, a);
    sleep(1);
  }
  wait(NULL);
  printf("\t\t\t\t parent done: child PID %d, %i\n", childPID, a);
  exit(0);
}

    
      

        
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char* argv[]) {
  pid_t childPID;
  int a;

  childPID = fork();
   
  if (childPID == 0 ) {
    for(a=0; a<10; a++) {
      printf("for loop: child PID %d, %i \n", getpid(), a);
      sleep(2);
    }
    printf("child done: child PID %d \n", getpid());
    exit(0);
  }

  for(a=0; a<10; a++) {
    printf("\t\t\t\t parent:   child PID %d, %i\n", childPID, a);
    sleep(1);
  }
  printf("\t\t\t\t parent done: child PID %d, %i\n", childPID, a);
  exit(0);
}

    
      

Aufgabe T-3-3

1. Überlegen Sie sich vier sinnvolle Anforderungen an CPU-Zuteilungsstrategien (Scheduling-Strategien).
2. Nennen Sie drei preemptive Scheduling-Strategien, und erklären Sie in kurzen Stichworten ihre Arbeitsweise.
3. Versuchen Sie, die in b) gewählten Strategien hinsichtlich der vier Anforderungen aus a) zu beurteilen. Beurteilen Sie außerdem den Umgang der Strategien mit besonders kurzen sowie mit besonders langen Prozessen.

Praktische Aufgaben (Blatt 3)

Aufgabe P-3-1

1. Schreiben Sie ein einfaches C-Programm, das in einer Schleife fork() -Aufrufe tätigt. Die Anzahl n der Schleifendurchläufe soll als Aufrufparameter über die Konsole übergeben werden. Jeder erzeugte Kindprozess (sowie der ursprüngliche Vaterprozess) soll genau einmal seine Parent-Prozess-ID (PPID) ausgeben.
2. Testen Sie Ihr Programm mit verschiedenen Werten für n. Dokumentieren Sie die Ausgabe.
3. Zeichnen Sie den Prozess-Baum, der bei n : = 4 entsteht. Lesen Sie daraus ab, wie viele unterschiedliche PPIDs jeweils in welcher Häufigkeit in der Ausgabe vorkommen können. Überprüfen Sie anhand der tatsächlichen Ausgabe. Wie viele direkte Kinder, Enkel, Urenkel usw. wurden also jeweils erzeugt?
4. Geben Sie eine allgemeine Formel für die Zahl der erzeugten Kindprozesse in Abhängigkeit von n an.
5. Schreiben Sie jetzt ein weiteres C-Programm, das durch einen fork() -Aufruf zunächst einen ersten Kindprozess und anschließend durch einen zweiten fork() -Aufruf einen zweiten Kindprozess erzeugt. Achten Sie aber darauf, dass keiner der beiden Kindprozesse seinerseits Kindprozesse erzeugt! (Es sollen also insgesamt genau zwei direkte Kindprozesse vom ursprünglichen Prozess angelegt werden.) Jeder der beiden Kindprozesse soll nun das Programm aus Teilaufgabe a) einmal ausführen (Aufrufparameter n beliebig). Verwenden Sie einen passenden Aufruf aus der Familie der exec*() -Familie, um die Überlagerung der Kindprozesse zu realisieren.

Aufgabe P-3-2

Aufgabe P-3-3

• Wie funktioniert der pipe() Systemaufruf?
• Wann muss die Pipe erzeugt werden? Vor oder nach der Erzeugung des Sohns?
• Schreiben Sie getrennte Funktionen für Vater bzw. Sohn.
• Vater:
  • Welche Operation muss der Vater ausführen, sodass er nur in die Pipe schreiben kann?
  • Wie kann aus einer Datei gelesen werden? Belegen Sie den Speicher für den Lesepuffer dynamisch.
  • Mittels welcher Operation kann in die Pipe geschrieben werden?
  • Welche Operation muss auf der Pipe ausgeführt werden, nachdem die Datei vollständig geschrieben wurde?
  • Falls der Vater mit dem Schreiben fertig ist, bevor der Sohn seine Ausgabe abgeschlossen hat: Welche Maßnahmen muss der Vater ergreifen, damit der Sohn seine Arbeit korrekt beenden kann?
• Sohn:
  • Welche Operation muss der Sohn ausführen, sodass er aus der Pipe nur lesen kann?
  • Mittels welcher Operation kann aus der Pipe gelesen werden? Belegen Sie den Speicher für den Lesepuffer dynamisch.
  • Wie wird auf STDOUT ausgegeben?
  • Wie erkennt der Sohn, dass nichts mehr aus der Pipe gelesen werden kann?
• Achten Sie auf eine detaillierte, zuverlässige Fehlerbehandlung.