Pipes in Linux mit C++: Tutorial für COP4600 ex7

Einführung in Pipes unter Linux

Pipes sind ein grundlegendes Konzept der Interprozesskommunikation (IPC) in Linux. Sie ermöglichen es, die Ausgabe eines Prozesses direkt als Eingabe eines anderen Prozesses zu verwenden – ohne Umwege über temporäre Dateien. In diesem Tutorial lernst du die drei wichtigsten Arten von Pipes kennen: einfache Pipes (Shell), Named Pipes (FIFOs) und den pipe()-Systemaufruf in C++. Dieses Wissen ist essenziell für dein COP4600 ex7: pipes Assignment und hilft dir, Betriebssystemkonzepte praxisnah zu verstehen.

Stell dir vor, du arbeitest an einer KI-gesteuerten Bildverarbeitungs-App: Ein Prozess lädt Bilder, ein anderer filtert sie, ein dritter speichert die Ergebnisse. Mit Pipes kannst du diese Schritte nahtlos verbinden – ähnlich wie bei einer Datenpipeline in modernen Machine-Learning-Frameworks. Auch in der Finanzwelt werden Pipes genutzt, um Echtzeit-Aktienkurse zu verarbeiten. Genau diese Effizienz macht Pipes so wertvoll.

1. Einfache Pipes (Shell-Pipes)

Der Pipe-Operator | in der Bash leitet die Standardausgabe des linken Befehls an die Standardeingabe des rechten Befehls weiter. Ein klassisches Beispiel aus der Aufgabenstellung: cat result.txt | grep -o "COP4600" | wc -l zählt, wie oft "COP4600" in der Datei vorkommt. Der Inhalt der Datei wird durch die Pipe an grep übergeben, das die Treffer filtert und an wc weiterleitet.

In Teil 1 deines Assignments sollst du ein C++-Programm schreiben, das die Ausgabe von part1.o analysiert. Wenn du ./part1.o | ./dein_programm ausführst, liest dein Programm die Ausgabe zeilenweise und ermittelt, bei welcher Operation der Fehler aufgetreten ist. Ein möglicher Ansatz: Suche nach dem Schlüsselwort "Operation" und extrahiere die Nummer. Hier ein einfaches Code-Snippet:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string line;
    while (getline(cin, line)) {
        if (line.find("failed") != string::npos) {
            size_t pos = line.find("Operation");
            if (pos != string::npos) {
                cout << "Program failed on operation " << line.substr(pos+10) << endl;
                break;
            }
        }
    }
    return 0;
}

Dieses Programm demonstriert, wie du über die Standardeingabe (cin) die Daten aus der Pipe empfängst. Achte darauf, dass part1.o mit sudo chmod +x ./part1.o ausführbar gemacht wird.

2. Named Pipes (FIFOs)

Named Pipes sind persistent im Dateisystem und werden mit mkfifo erstellt. Sie blockieren, bis ein Leser und ein Schreiber verbunden sind. In Teil 2 modifizierst du dein Programm, sodass es aus einer Named Pipe liest, während part1.o in dieselbe Pipe schreibt. Das erfordert zwei Terminals oder Hintergrundprozesse.

Schritte zur Implementierung:

Erstelle eine Named Pipe: mkfifo mypipe
Starte dein modifiziertes Programm (es öffnet die Pipe zum Lesen und blockiert, bis Daten kommen).
In einem anderen Terminal: ./part1.o > mypipe
Dein Programm empfängt die Daten und gibt das Ergebnis aus.

Dein C++-Code öffnet die Pipe wie eine Datei:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    ifstream pipe("mypipe");
    string line;
    while (getline(pipe, line)) {
        if (line.find("failed") != string::npos) {
            size_t pos = line.find("Operation");
            if (pos != string::npos) {
                cout << "Program failed on operation " << line.substr(pos+10) << endl;
                break;
            }
        }
    }
    pipe.close();
    return 0;
}

Named Pipes sind nützlich, wenn Prozesse unabhängig gestartet werden und nicht in einer Eltern-Kind-Beziehung stehen – ähnlich wie Microservices, die über Message Queues kommunizieren.

3. Pipe-Systemaufruf in C++

Der pipe()-Systemaufruf erzeugt ein unidirektionales Datenpaar (Lese- und Schreibende) innerhalb eines Prozesses. Meist wird er mit fork() kombiniert, um zwischen Eltern- und Kindprozessen zu kommunizieren. Teil 3 deines Assignments verlangt zwei Kindprozesse und vier Pipes: Eine zum Senden der Zahlen, zwei zum Zurücksenden der sortierten Liste und eine für den Median.

Hier ein Grundgerüst:

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
using namespace std;

int main(int argc, char* argv[]) {
    if (argc != 6) {
        cerr << "Bitte 5 Integer als Argumente übergeben." << endl;
        return 1;
    }

    int p1[2], p2[2], p3[2], p4[2];
    pipe(p1); pipe(p2); pipe(p3); pipe(p4);

    // Kind 1: Sortieren
    pid_t child1 = fork();
    if (child1 == 0) {
        // Schließe unnötige Enden
        close(p1[1]); close(p2[0]); close(p3[0]); close(p3[1]); close(p4[0]); close(p4[1]);
        int nums[5];
        read(p1[0], nums, sizeof(nums));
        // Sortiere (z.B. Bubble Sort)
        for (int i = 0; i < 5; i++)
            for (int j = i+1; j < 5; j++)
                if (nums[i] > nums[j]) swap(nums[i], nums[j]);
        write(p2[1], nums, sizeof(nums)); // an Parent
        write(p3[1], nums, sizeof(nums)); // an Child2
        close(p1[0]); close(p2[1]); close(p3[1]);
        exit(0);
    }

    // Kind 2: Median
    pid_t child2 = fork();
    if (child2 == 0) {
        close(p1[0]); close(p1[1]); close(p2[0]); close(p2[1]); close(p3[1]); close(p4[0]);
        int nums[5];
        read(p3[0], nums, sizeof(nums));
        int median = nums[2]; // Sortierte Liste, Index 2 ist Median
        write(p4[1], &median, sizeof(median));
        close(p3[0]); close(p4[1]);
        exit(0);
    }

    // Parent
    close(p1[0]); close(p2[1]); close(p3[0]); close(p3[1]); close(p4[1]);
    int nums[5];
    for (int i = 0; i < 5; i++) nums[i] = atoi(argv[i+1]);
    write(p1[1], nums, sizeof(nums));
    close(p1[1]);

    int sorted[5];
    read(p2[0], sorted, sizeof(sorted));
    cout << "Sortierte Liste: ";
    for (int i = 0; i < 5; i++) cout << sorted[i] << " ";
    cout << endl;

    int median;
    read(p4[0], &median, sizeof(median));
    cout << "Median: " << median << endl;

    wait(NULL); wait(NULL);
    close(p2[0]); close(p4[0]);
    return 0;
}

Dieses Beispiel zeigt, wie Pipes innerhalb eines Programms Datenflüsse steuern – ähnlich wie Datenpipes in einer E-Commerce-Plattform, die Bestellungen validieren, verarbeiten und archivieren.

Häufige Fehler und Tipps

Blockierung: Named Pipes blockieren, bis beide Seiten verbunden sind. Starte zuerst den Leser, dann den Schreiber.
Schließen von Pipes: Vergiss nicht, nicht benötigte Pipe-Enden in jedem Prozess zu schließen, sonst kann es zu Deadlocks kommen.
Puffergröße: Pipes haben eine begrenzte Kapazität (meist 65536 Bytes). Bei großen Datenmengen ist das zu beachten.
Fehlerbehandlung: Prüfe die Rückgabewerte von pipe(), fork() und read()/write().

Fazit

Mit diesem Tutorial hast du die Grundlagen von Pipes in Linux verstanden – von der Shell über Named Pipes bis hin zum Systemaufruf. Diese Kenntnisse sind nicht nur für dein COP4600 Assignment wichtig, sondern auch für reale Anwendungen wie Datenpipelines in der Cloud oder Echtzeit-Kommunikation in Spielen. Experimentiere mit den Beispielen und passe sie an deine Bedürfnisse an. Viel Erfolg!