110 lines
5 KiB
Bash
110 lines
5 KiB
Bash
#!/usr/bin/env bash
|
|
# ==============================================================================
|
|
# Bash 09: Parallelisierung mit xargs, GNU parallel & Background Workers
|
|
# ==============================================================================
|
|
# In diesem Modul lernst du, rechen- oder I/O-intensive Aufgaben im Terminal
|
|
# parallel auf mehreren CPU-Cores abzuarbeiten.
|
|
# ==============================================================================
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 1: Parallele Verarbeitung von Dateizeilen mit xargs
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `parallel_xargs_process`.
|
|
# Parameter:
|
|
# $1: Pfad zu einer Datei mit Einträgen (eine Zeile pro Item)
|
|
# $2: Maximale Anzahl paralleler Prozesse (z.B. 4)
|
|
# Verhalten:
|
|
# - Liest jede Zeile aus $1
|
|
# - Verarbeitet jedes Item parallel mit `xargs -n 1 -P "$2"`
|
|
# - Für jedes Item soll ausgegeben werden: "PROCESSED: <item>"
|
|
# - Bei fehlender oder nicht existierender Datei: Return 1
|
|
# ------------------------------------------------------------------------------
|
|
parallel_xargs_process() {
|
|
local input_file="${1:-}"
|
|
local max_procs="${2:-2}"
|
|
|
|
# TODO: Prüfe ob input_file existiert, ansonsten return 1
|
|
# TODO: Nutze cat/xargs mit -n 1 und -P "$max_procs", um jedes Item mit "PROCESSED: $item" auszugeben
|
|
echo "TODO: Implementiere parallel_xargs_process"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 2: Background Workers mit PID-Tracking & wait
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `background_workers_wait`.
|
|
# Parameter:
|
|
# $@: Eine Liste von Aufgabennamen (z.B. "taskA" "taskB" "taskC")
|
|
# Verhalten:
|
|
# - Startet für jeden übergebenen Aufgabennamen einen Hintergrundjob (`&`),
|
|
# der folgendes ausgibt: "WORKER_START: <task>" und nach einer kurzen
|
|
# Operation (z.B. sleep 0.01) ausgibt: "WORKER_DONE: <task>"
|
|
# - Sammelt die PIDs aller gestarteten Jobs in einem Bash-Array (`pids+=($!)`).
|
|
# - Wartet mit `wait` auf das Ende aller Hintergrundjobs.
|
|
# - Gibt nach erfolgreichem Warten aus: "ALL_WORKERS_FINISHED"
|
|
# - Liefert Return-Code 0.
|
|
# ------------------------------------------------------------------------------
|
|
background_workers_wait() {
|
|
local tasks=("$@")
|
|
|
|
# TODO: Prüfe ob Aufgaben übergeben wurden, wenn nicht return 1
|
|
# TODO: Starte für jede Task einen Background-Prozess (&) und tracke $!
|
|
# TODO: Warte mit `wait "${pids[@]}"`
|
|
# TODO: Gib "ALL_WORKERS_FINISHED" aus
|
|
echo "TODO: Implementiere background_workers_wait"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 3: Paralleler Batch-Rechner (Numerische Transformation)
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `parallel_batch_calculator`.
|
|
# Parameter:
|
|
# $1: Pfad zu einer Datei mit Ganzzahlen (eine Zahl pro Zeile)
|
|
# $2: Anzahl paralleler Worker (Default: 4)
|
|
# Verhalten:
|
|
# - Berechnet für jede Zahl n das Quadrat (n * n).
|
|
# - Führt die Berechnung parallel via xargs oder Background-Workers durch.
|
|
# - Gibt das Ergebnis im Format "<n>^2 = <quadrat>" aus, sortiert nach <n> numerisch aufsteigend.
|
|
# - Beispiel Eingabe: 3, 5, 2
|
|
# - Ausgabe:
|
|
# 2^2 = 4
|
|
# 3^2 = 9
|
|
# 5^2 = 25
|
|
# - Bei ungültiger Datei return 1.
|
|
# ------------------------------------------------------------------------------
|
|
parallel_batch_calculator() {
|
|
local numbers_file="${1:-}"
|
|
local max_procs="${2:-4}"
|
|
|
|
# TODO: Validiere Datei
|
|
# TODO: Berechne Quadrate parallel und gebe sie numerisch sortiert aus
|
|
echo "TODO: Implementiere parallel_batch_calculator"
|
|
return 1
|
|
}
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# TODO 4: Throttling & Concurrency Pool (Max. N aktive Jobs)
|
|
# ------------------------------------------------------------------------------
|
|
# Implementiere die Funktion `throttle_concurrent_jobs`.
|
|
# Parameter:
|
|
# $1: Gesamtanzahl der zu startenden Jobs (z.B. 6)
|
|
# $2: Maximale Anzahl gleichzeitig laufender Jobs (z.B. 2)
|
|
# Verhalten:
|
|
# - Startet Jobs 1 bis $1 im Hintergrund.
|
|
# - Jeder Job gibt aus: "JOB_RUNNING: <id>"
|
|
# - Stellt sicher, dass zu KEINEM Zeitpunkt mehr als $2 Jobs gleichzeitig laufen.
|
|
# (Tipp: Prüfe die Anzahl laufender Jobs via `jobs -p | wc -l` oder nutze `wait -n`).
|
|
# - Wartet am Ende, bis wirklich alle Jobs beendet sind.
|
|
# - Gibt am Ende aus: "THROTTLE_POOL_COMPLETED"
|
|
# ------------------------------------------------------------------------------
|
|
throttle_concurrent_jobs() {
|
|
local total_jobs="${1:-0}"
|
|
local max_concurrent="${2:-2}"
|
|
|
|
# TODO: Starte total_jobs und drossle Concurrency auf max_concurrent
|
|
# TODO: Warte auf verbleibende Jobs
|
|
# TODO: Gib "THROTTLE_POOL_COMPLETED" aus
|
|
echo "TODO: Implementiere throttle_concurrent_jobs"
|
|
return 1
|
|
}
|