Prozesse
& Threads

A und B werden einmalig geladen. Alle Threads teilen die Daten im Speicher, berechnen je einen Zeilenbereich und schreiben in den gemeinsamen Speicher.

Der Eltern­prozess forkt N Kinder. Jedes liest A und B selbst, berechnet seinen Zeilenbereich und schreibt eine Temp-Datei. Der Elternprozess setzt C zusammen.

{{ pjNote }}

// matrix_multiply.cpp — rechnet die Zeilen [rowStart, rowEnd)
void multiplyRange(const Matrix& A, const Matrix& B,
                   Matrix& C, int rowStart, int rowEnd) {
  for (int i = rowStart; i < rowEnd; ++i)
    for (int j = 0; j < B.cols; ++j) {
      long sum = 0;
      for (int l = 0; l < A.cols; ++l)
        sum += A.at(i, l) * B.at(l, j);
      C.at(i, j) = sum;              // schreibt in gemeinsames C
    }
}

Jeder Arbeiter bekommt nur seinen Bereich [rowStart, rowEnd). Die innerste Schleife bildet das Skalarprodukt aus Zeile i von A und Spalte j von B — genau die Formel aus Kapitel 07. Weil jede Zeile von C unabhängig ist, kommen sich die Arbeiter nie in die Quere.

// main.cpp (Thread-Variante) — starten & einsammeln
int rowsPerThread = A.rows / numThreads;
std::vector<std::thread> pool;

for (int t = 0; t < numThreads; ++t) {
  int start = t * rowsPerThread;
  int end   = (t == numThreads - 1) ? A.rows
                                  : start + rowsPerThread;
  pool.emplace_back(multiplyRange, std::cref(A), std::cref(B),
                    std::ref(C), start, end);
}
for (auto& th : pool) th.join();   // auf alle warten

Alle Threads teilen sich A, B und C im selben Adressraum — deshalb werden sie per std::cref / std::ref als Referenz übergeben, ohne zu kopieren. Der letzte Thread bekommt A.rows als Ende, damit keine Zeile fehlt. join() blockiert, bis jeder Thread fertig ist.

// main.cpp (Prozess-Variante) — Kinder abspalten
for (int p = 0; p < numProcs; ++p) {
  pid_t pid = fork();            // Prozess duplizieren
  if (pid == 0) {                // 0 = wir sind das Kind
    int start = p * rowsPerProc;
    int end   = (p == numProcs - 1) ? A.rows
                                    : start + rowsPerProc;
    computeAndWriteTemp(A, B, start, end, p);
    std::exit(0);                // Kind beendet sich sauber
  }
  children.push_back(pid);         // Eltern merkt sich die PID
}

fork() dupliziert den Prozess: im Kind liefert es 0, im Elternprozess die PID des Kindes. Jedes Kind hat seinen eigenen Adressraum, liest A und B selbst und schreibt sein Teilergebnis in eine Temp-Datei. std::exit(0) beendet das Kind — sonst liefe es in der Schleife des Elternteils weiter und würde selbst forken.

// Eltern: auf alle Kinder warten, Zombies einsammeln
for (pid_t pid : children) {
  int status;
  waitpid(pid, &status, 0);         // blockiert bis Kind endet
  if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
    std::cerr << "Kind " << pid << " fehlgeschlagen";
}
assembleResult(C, numProcs);         // Temp-Dateien -> C

waitpid() holt den Exit-Status jedes Kindes ab — genau der „reaping“-Vorgang aus Kapitel 03. WIFEXITED und WEXITSTATUS prüfen, ob das Kind sauber mit Code 0 endete. Erst danach liest der Elternprozess die Temp-Dateien und setzt C zusammen.