{"id":879,"date":"2026-07-30T12:23:24","date_gmt":"2026-07-30T12:23:24","guid":{"rendered":"https:\/\/matforge.org\/?p=879","raw":"https:\/\/matforge.org\/?p=879"},"modified":"2026-07-30T12:23:24","modified_gmt":"2026-07-30T12:23:24","slug":"hpc-python-workflows-from-laptop-to-supercomputer","status":"publish","type":"post","link":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/","title":{"rendered":"HPC-Python-Workflows: Vom Laptop zum Supercomputer","raw":"HPC-Python-Workflows: Vom Laptop zum Supercomputer"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 8<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><h2>Schl\u00fcssel zum Mitnehmen<\/h2>\n<ul>\n<li>Python-Code kann auf einem Laptop und einem gro\u00dfen HPC-System mit der gleichen Kernlogik ausgef\u00fchrt werden, wenn der Workflow MPI4Py oder Dask korrekt verwendet.<\/li>\n<li>Die Reproduzierbarkeit der Umgebung ist oft der schwierigste Teil der HPC-Arbeit. Conda-Umgebungen, Lockfiles und Job-Skripte helfen dabei, es zu l\u00f6sen.<\/li>\n<li>Der Workflow besteht aus drei Phasen: Prototyp lokal, parallelisieren mit MPI4PY oder DASK und Senden von Jobs \u00fcber SLURM, PBS oder einen anderen Scheduler.<\/li>\n<li>Schreiben Sie nicht die gesamte Codebasis f\u00fcr den Cluster neu. Halten Sie die Simulationslogik stabil und wickeln Sie sie mit reproduzierbarer Umgebung und parallelen Ausf\u00fchrungsschichten ein.<\/li>\n<\/ul>\n<p>Sie schreiben ein Simulationsskript auf Ihren Laptop. Sie testen es mit kleinen Datens\u00e4tzen. Es l\u00e4uft in Minuten. Dann ben\u00f6tigen Sie Tausende von Kernen und Hunderte von Gigabyte RAM, um es im Ma\u00dfstab auszuf\u00fchren.<\/p>\n<p>Schreiben Sie die gesamte Codebasis um?<\/p>\n<p>Nein. Der gleiche Python-Code, der auf Ihrem Laptop ausgef\u00fchrt wird, kann auf einem Supercomputer mit minimalen \u00c4nderungen ausgef\u00fchrt werden. Der Schl\u00fcssel ist nicht neu zu schreiben. es ist umwickelt.<\/p>\n<p>Sie ben\u00f6tigen drei Dinge: eine reproduzierbare Umgebung, ein paralleles Ausf\u00fchrungsmodell und ein Auftrags\u00fcbermittlungsskript f\u00fcr den Clusterplaner.<\/p>\n<p>Dieser Leitfaden durchl\u00e4uft den vollst\u00e4ndigen Workflow vom lokalen Prototyp bis zur HPC-Produktion, ohne dass Sie Ihre Kernsimulationslogik \u00e4ndern.<\/p>\n<h2>Der dreistufige HPC-Python-Workflow<\/h2>\n<p>Die meisten HPC-Python-Projekte folgen unabh\u00e4ngig vom wissenschaftlichen Bereich dem gleichen dreistufigen Muster.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>Ziel ist es, diese Phasen schrittweise durchzugehen. Beginnen Sie mit einer funktionierenden lokalen Version. F\u00fcgen Sie die parallele Ausf\u00fchrung erst hinzu, wenn die Logik korrekt ist. Erst nach kleinen parallelen Tests an den Cluster senden.<\/p>\n<h2>Stufe 1: Aufbau einer reproduzierbaren Umgebung<\/h2>\n<p>Bevor Sie parallelen Code schreiben, ben\u00f6tigen Sie eine zuverl\u00e4ssige Entwicklungsumgebung. Hier scheitern viele wissenschaftliche Workflows zuerst.<\/p>\n<h3>Warum Reproduzierbarkeit f\u00fcr HPC-Cluster schwierig ist<\/h3>\n<p>HPC-Cluster sind gemeinsam genutzte Systeme. Viele Forschungsgruppen verwenden dieselbe Infrastruktur, und Systempakete k\u00f6nnen sich im Laufe der Zeit \u00e4ndern. Eine heutige Simulation kann nach Modulaktualisierungen, Compiler\u00e4nderungen oder Paketversions\u00e4nderungen sechs Monate sp\u00e4ter abbrechen.<\/p>\n<p>Die L\u00f6sung ist das Umweltmanagement. Conda wird h\u00e4ufig verwendet, weil es Pakete aus dem System Python isoliert und sowohl kompilierte Abh\u00e4ngigkeiten als auch Python-Pakete verwalten kann.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Eine einzelne Umgebungsdatei bietet Mitarbeitern und zuk\u00fcnftigen Benutzern eine klare M\u00f6glichkeit, den Software-Stack neu zu erstellen. Verwenden Sie f\u00fcr eine strengere Reproduzierbarkeit Lockfiles, die jede Paketversion anheften und eine Abh\u00e4ngigkeit aufbauen.<\/p>\n<h3>Conda vs Venv: Warum Conda oft auf HPC gewinnt<\/h3>\n<p>Pythons integrierte <code>venv<\/code>  funktioniert gut f\u00fcr reine Python-Pakete. HPC-Workflows h\u00e4ngen h\u00e4ufig von kompilierten wissenschaftlichen Bibliotheken, MPI-Runtimes, HDF5, BLAS, CUDA und anderen Komponenten auf Systemebene ab.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Funktion<\/th>\n<th>Venv<\/th>\n<th>Konda<\/th>\n<\/tr>\n<tr>\n<td>Reine Python-Pakete<\/td>\n<td>Ja<\/td>\n<td>Ja<\/td>\n<\/tr>\n<tr>\n<td>Abh\u00e4ngigkeiten auf Systemebene wie MPI und HDF5<\/td>\n<td>Nein<\/td>\n<td>Ja<\/td>\n<\/tr>\n<tr>\n<td>Plattform\u00fcbergreifende Konsistenz<\/td>\n<td>Beschr\u00e4nkt<\/td>\n<td>Stark<\/td>\n<\/tr>\n<tr>\n<td>GPU-Beschleunigungspakete wie Cupy oder PyTorch CUDA<\/td>\n<td>Manuelle Einrichtung<\/td>\n<td>Mehr automatisierte Einrichtung<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Conda bietet Reproduzierbarkeit \u00fcber mehr wissenschaftliche Stapel. Das ist bei der Arbeit mit MPI4Py von Bedeutung, da die MPI-Runtime- und Python-Umgebung sowohl auf dem lokalen Computer als auch auf dem Cluster kompatibel sein muss.<\/p>\n<h2>Stufe 2: Parallelisierung Ihres Python-Codes<\/h2>\n<p>Sobald die lokale Version funktioniert, ist der n\u00e4chste Schritt die Parallelisierung. In Python-HPC-Workflows sind zwei Tools besonders verbreitet:<\/p>\n<ol>\n<li>MPI4PY f\u00fcr eine feink\u00f6rnige verteilte Steuerung \u00fcber viele Knoten.<\/li>\n<li>Dask f\u00fcr \u00fcbergeordnete Parallelit\u00e4t mit weniger Code\u00e4nderungen.<\/li>\n<\/ol>\n<h3>Warum Sie mpi4py brauchen<\/h3>\n<p>Die globale Dolmetschersperre von Python begrenzt die wahre Multi-Thread-Python-Ausf\u00fchrung in einem Prozess. Das <code>multiprocessing<\/code>-Modul kann auf einer Maschine parallelisieren, skaliert jedoch nicht \u00fcber mehrere Rechenknoten hinweg.<\/p>\n<p>MPI4PY bietet Python-Bindungen f\u00fcr MPI, die Nachrichten\u00fcbermittlungsschnittstelle. MPI ist eine Standard-API f\u00fcr verteiltes Parallel-Computing und wird h\u00e4ufig auf HPC-Systemen verwendet.<\/p>\n<p>Bei MPI4Py f\u00fchrt jeder Prozess das gleiche Skript aus, erh\u00e4lt jedoch einen eindeutigen Rang. Dieser Rang steuert, welchen Teil der Arbeitslast jeder Prozess verarbeitet.<\/p>\n<h3>Grundlegendes mpi4py-Muster: Hallo Welt<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Starten Sie das Skript mit MPI:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Dies startet 16 unabh\u00e4ngige Python-Prozesse. Jeder Prozess f\u00fchrt das gleiche Skript aus, aber jeder hat ein anderes <code>rank<\/code> .<\/p>\n<h3>Das Datenmodell: unabh\u00e4ngige Prozesse<\/h3>\n<p>MPI-Prozesse teilen sich standardm\u00e4\u00dfig keinen Speicher. Jeder Prozess hat seinen eigenen Speicherplatz. Um Informationen auszutauschen, m\u00fcssen Prozesse explizit Daten senden, empfangen, \u00fcbertragen, sammeln oder verkleinern.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Dieses explizite Kommunikationsmodell ist ein Grund, warum MPI gut skaliert. Jeder Rang besitzt seinen lokalen Speicher, und die Kommunikation erfolgt nur, wenn Sie ihn anfordern.<\/p>\n<h3>Workload-Verteilung: Das Kernmuster<\/h3>\n<p>Die meisten wissenschaftlichen MPI-Workflows folgen demselben Muster: Teilen Sie das Problem, berechnen Sie lokal und reduzieren Sie die Ergebnisse.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Dieses Muster gilt f\u00fcr viele Simulationsaufgaben:<\/p>\n<ul>\n<li>Monte-Carlo-Simulationen, bei denen jeder Rang unabh\u00e4ngige Stichproben verarbeitet.<\/li>\n<li>Parameter-Sweeps, bei denen jeder Rang verschiedene Parameters\u00e4tze testet.<\/li>\n<li>Dom\u00e4nenzerlegung, wobei jeder Rang einen Teil des Simulationsrasters besitzt.<\/li>\n<li>Molekulare Dynamik, bei der die Rechenkr\u00e4fte f\u00fcr verschiedene Teilchen-Teilmengen rangieren.<\/li>\n<\/ul>\n<h3>Die kollektive Kommunikations-Toolbox<\/h3>\n<p>MPI4Py bietet kollektive Vorg\u00e4nge, die in der Regel einfacher und effizienter sind als benutzerdefinierte Punkt-zu-Punkt-Messaging.<\/p>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Betrieb<\/th>\n<th>Was es tut<\/th>\n<th>Wann zu verwenden<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Ein Prozess sendet die gleichen Daten an alle R\u00e4nge<\/td>\n<td>Teilen von Anfangsbedingungen, Konstanten oder Konfigurationswerten<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Verteilt Teile eines Arrays \u00fcber R\u00e4nge<\/td>\n<td>Dom\u00e4nenzerlegung oder Workload-Partitionierung<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Sammelt Daten aus allen Reihen<\/td>\n<td>Sammeln von Teilausgaben<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Aggregiert Werte wie SUM, MAX oder MIN<\/td>\n<td>Energien summieren oder globale Metriken sammeln<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>Aggregiert Werte und gibt jedem Rang das Ergebnis<\/td>\n<td>Synchronisieren des globalen Status \u00fcber alle Prozesse<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Verwenden Sie nach M\u00f6glichkeit kollektive Kommunikation. Es ist normalerweise einfacher und effizienter als die manuelle Koordinierung vieler Sends und Empfangen.<\/p>\n<h3>Wann sollte man das stattdessen verwenden?<\/h3>\n<p>Dask sitzt zwischen Serial Python und MPI. Dies ist n\u00fctzlich, wenn die Arbeitslast peinlich parallel ist, z. B. die gleiche Simulation mit vielen Parameters\u00e4tzen oder Anfangsbedingungen auszuf\u00fchren.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>Der Vorteil von Dask ist, dass Sie viele Workflows parallelisieren k\u00f6nnen, ohne die Simulation um R\u00e4nge und Kommunikatoren neu zu gestalten.<\/p>\n<h3>mpi4py vs. Dask: Welche w\u00e4hlen?<\/h3>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Kriterium<\/th>\n<th>MPI4PY<\/th>\n<th>Dask<\/th>\n<\/tr>\n<tr>\n<td>Lernkurve<\/td>\n<td>Steiler, weil Sie R\u00e4nge und Kommunikatoren verstehen m\u00fcssen<\/td>\n<td>sanfter, weil es bekannte Python-Aufgabenmuster verwendet<\/td>\n<\/tr>\n<tr>\n<td>Feinkornsteuerung<\/td>\n<td>Ausgezeichnet, weil jede Kommunikation explizit ist<\/td>\n<td>Eingeschr\u00e4nkt durch die Aufgabengrafik-Abstraktion<\/td>\n<\/tr>\n<tr>\n<td>Speichereffizienz<\/td>\n<td>Hoch, weil jeder Rang sein eigenes St\u00fcck speichert<\/td>\n<td>gem\u00e4\u00dfigt, weil die Arbeitnehmer den Overhead erh\u00f6hen<\/td>\n<\/tr>\n<tr>\n<td>Passend f\u00fcr<\/td>\n<td>Gro\u00dfformatige PDE-Solver und dom\u00e4nenzerlegte Simulationen<\/td>\n<td>Monte Carlo, Parameter-Sweeps und Datenanalyse<\/td>\n<\/tr>\n<tr>\n<td>Beste Skala<\/td>\n<td>Dichte Parallelit\u00e4t \u00fcber viele Knoten<\/td>\n<td>Schwache Skalierung \u00fcber m\u00e4\u00dfige Arbeiterz\u00e4hlungen<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Beginnen Sie mit DASK f\u00fcr Prototyping und peinlich parallele Workloads. Gehen Sie zu MPI4PY, wenn Sie \u00fcber viele Knoten hinweg eine strenge Kontrolle \u00fcber Kommunikation, Speicher und Skalierung ben\u00f6tigen.<\/p>\n<h2>Stufe 3: Einreichen des Clusters<\/h2>\n<p>Nach lokalem Testen und Parallelisierung ist der n\u00e4chste Schritt die Clusterbereitstellung. Die meisten Cluster verwenden einen Jobplaner. Slurm ist eine der h\u00e4ufigsten.<\/p>\n<h3>Das Slurm-Job-Skript<\/h3>\n<p>Ein Slurm-Job-Skript teilt dem Scheduler mit, welche Ressourcen Sie ben\u00f6tigen und wie der Code ausgef\u00fchrt wird.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Wichtige Parameter sind:<\/p>\n<ul>\n<li><code>--nodes<\/code>: Anzahl der Rechenknoten.<\/li>\n<li><code>--tasks-per-node<\/code>: Anzahl der MPI-Aufgaben pro Knoten.<\/li>\n<li><code>--cpus-per-task<\/code>: CPU-Kernen, die jeder Aufgabe zugewiesen werden.<\/li>\n<li><code>--time<\/code>: Wanduhrgrenze. Jobs werden normalerweise gestoppt, wenn sie es \u00fcberschreiten.<\/li>\n<li><code>--output<\/code>: Ausgabedateimuster. <code>%j<\/code> F\u00fcgt die Job-ID ein.<\/li>\n<\/ul>\n<h3>Laufen auf Clustern ohne Slurm<\/h3>\n<p>Nicht jeder Cluster verwendet Slurm. H\u00e4ufige Alternativen sind:<\/p>\n<ul>\n<li>PBS oder Drehmoment, normalerweise unter Verwendung von <code>qsub<\/code> .<\/li>\n<li>LSF, normalerweise mit <code>bsub<\/code> .<\/li>\n<li>Kobalt oder andere ortsspezifische Scheduler.<\/li>\n<\/ul>\n<p>Die Syntax der Jobeinreichung \u00e4ndert sich, der Python-Code jedoch normalerweise nicht. MPI4PY und DASK sind meist planer-agnostisch, sobald sie korrekt gestartet wurden.<\/p>\n<h3>Interaktiver vs. Batch-Modus<\/h3>\n<p>Zum Debuggen sind interaktive L\u00e4ufe n\u00fctzlich:<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Verwenden Sie f\u00fcr die Produktion die Chargeneinreichung:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Interaktive Sitzungen eignen sich gut f\u00fcr kurze Tests. Batch-Jobs sind besser f\u00fcr Langstrecken, Arbeitslasten \u00fcber Nacht und Produktionssimulationen.<\/p>\n<h2>Der komplette Workflow: vom Laptop bis zur Produktion<\/h2>\n<p>Der \u00dcbergang vom lokalen Prototyp zur Clusterbereitstellung kann allm\u00e4hlich erfolgen. Die Kernsimulationslogik sollte stabil bleiben, w\u00e4hrend sich der Ausf\u00fchrungswrapper \u00e4ndert.<\/p>\n<h3>Schritt 1: Entwickeln und testen Sie lokal<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>Schritt 2: Parallelisierung hinzuf\u00fcgen<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>Schritt 3: An den Cluster senden<\/h3>\n<p>Speichern Sie ein Job-Skript wie <code>job_script.sh<\/code>:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>einreichen:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>Die Simulationslogik bleibt gleich. Der Wrapper \u00e4ndert die Aufteilung und den Start der Arbeitslast.<\/p>\n<h2>H\u00e4ufige Fallstricke und wie man sie vermeidet<\/h2>\n<h3>Fallfall 1: Zu viele Daten \u00fcbertragen<\/h3>\n<p>Das Senden gro\u00dfer Arrays von Rang 0 bis zu jedem Rang kann zu einem Kommunikationsengpass werden. Vermeiden Sie bei gro\u00dfen Simulationen, mehr Daten zu senden, als jeder Rang ben\u00f6tigt.<\/p>\n<p>Bessere Optionen sind:<\/p>\n<ul>\n<li>Verwenden Sie <code>Scatter<\/code> anstelle von <code>Bcast<\/code>, wenn jeder Rang nur eine Scheibe ben\u00f6tigt.<\/li>\n<li>Verwenden Sie die Dom\u00e4nenzerlegung, damit jeder Rang eine Region der Simulation besitzt.<\/li>\n<li>Lassen Sie f\u00fcr Monte Carlo jeden Rang seine eigenen Zufallsstichproben generieren, anstatt sie zu senden.<\/li>\n<\/ul>\n<h3>Fallstricke 2: \u00dcberalloverallcluster-Ressourcen<\/h3>\n<p>Wenn Sie mehr Knoten als Ihr Code anfordern, k\u00f6nnen Sie Zeit f\u00fcr die Zuweisung von Abf\u00e4llen verwenden und die Warteschlangenverz\u00f6gerung erh\u00f6hen.<\/p>\n<p>Beginnen Sie mit einem kleinen Testjob, z. B. 4 bis 8 Knoten. Beschleunigung messen. Skalieren erst, nachdem der Code n\u00fctzliche parallele Effizienz zeigt.<\/p>\n<h3>Fallfall 3: Vergessen der Gil in gemischtem Code<\/h3>\n<p>Numpy, Scipy und kompilierte C- oder Fortran-Bibliotheken geben h\u00e4ufig die Python-Global-Interpreter-Sperre w\u00e4hrend schwerer numerischer Operationen frei. Reine Python-Threads bieten normalerweise nicht den gleichen Nutzen.<\/p>\n<p>Wenn Ihr Workflow Python-Threads mit numerischen Bibliotheken mischt, hilft die Testskalierung sorgf\u00e4ltig, anstatt mehr Threads anzunehmen.<\/p>\n<h3>Fallfall 4: Umgebungsfehler auf dem Cluster<\/h3>\n<p>Ihr Laptop kann Python 3.11 verwenden, w\u00e4hrend das Clustermodul Python 3.9 bereitstellt. MPI4PY, MPI-Bibliotheken und kompilierte Abh\u00e4ngigkeiten k\u00f6nnen brechen, wenn Versionen nicht \u00fcbereinstimmen.<\/p>\n<p>Verwenden Sie eine Conda-Umgebung und dokumentieren Sie die genaue Einrichtung. Erstellen und testen Sie die Umgebung auf dem Cluster, bevor Sie gro\u00dfe Jobs ausf\u00fchren.<\/p>\n<h2>Entscheidungsleitfaden: Welche Parallelisierungsstrategie?<\/h2>\n<table class=\"custom-table\">\n<tbody>\n<tr>\n<th>Lage<\/th>\n<th>Empfohlener Ansatz<\/th>\n<\/tr>\n<tr>\n<td>Kleiner Datensatz und lokale Logiktests<\/td>\n<td>Serienpython mit numpy<\/td>\n<\/tr>\n<tr>\n<td>Einzelmaschine mit mehreren Kernen<\/td>\n<td>Python <code>multiprocessing<\/code> oder Dask <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8\u201364 Arbeiter und peinlich parallele Aufgaben<\/td>\n<td>Dask mit einem Cluster-Launcher<\/td>\n<\/tr>\n<tr>\n<td>64\u20131000 Knoten und dom\u00e4nenzerlegte PDEs<\/td>\n<td>mpi4py mit expliziter Workload-Verteilung<\/td>\n<\/tr>\n<tr>\n<td>Produktionssimulation auf \u00fcber 1000 Knoten<\/td>\n<td>MPI4PY, Scheduler-Job-Skripte und gesperrte Conda-Umgebung<\/td>\n<\/tr>\n<tr>\n<td>Recherchecode ohne garantierte Reproduzierbarkeit<\/td>\n<td>Dask, Conda-Umgebungsdatei und Job-Skript als Ausgangspunkt<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Ihr Parallelisierungstool sollte mit dem Ma\u00dfstab und der Struktur des Problems \u00fcbereinstimmen. Beginnen Sie kleiner als Sie denken und skalieren Sie nach der Messung der Leistung.<\/p>\n<h2>Verwandte Anleitungen<\/h2>\n<p>Zu verwandten Themen in wissenschaftlichen Simulations-Workflows:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">GPU-Beschleunigung f\u00fcr FIPY-Simulationen: Cupy- und Numba-Integrationshandbuch<\/a> \u2014 Wenn parallele CPU ist nicht genug.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">Leistungsprofilierung und -optimierung f\u00fcr Python-PDE-Solver: Ein praktischer Leitfaden <\/a> &#8211; Finden von Engp\u00e4ssen vor der Parallelisierung.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\"> Python-Debugging f\u00fcr wissenschaftlichen Code: Von Druckanweisungen bis Profiling <\/a> &#8211; Debuggen von parallelen Simulationen.<\/li>\n<\/ul>\n<h2>Zusammenfassung und n\u00e4chste Schritte<\/h2>\n<p>Bei HPC-Python-Workflows geht es um das Einpacken, nicht um das Umschreiben. Die gleiche Simulationslogik, die auf einem Laptop ausgef\u00fchrt wird, kann auf vielen Kernen ausgef\u00fchrt werden, wenn Sie die richtige Ausf\u00fchrungsstruktur erstellen.<\/p>\n<p>Der Arbeitsablauf ist:<\/p>\n<ol>\n<li>Sperren Sie die Umgebung mit Conda, damit der Code konsistent \u00fcber alle Systeme l\u00e4uft.<\/li>\n<li>F\u00fcgen Sie Parallelit\u00e4t mit MPI4PY f\u00fcr eine feink\u00f6rnige verteilte Steuerung oder einen Stab f\u00fcr die Parallelit\u00e4t von Aufgaben hinzu.<\/li>\n<li>Senden Sie Jobs \u00fcber Slurm, PBS, LSF oder den von Ihrem Cluster verwendeten Scheduler.<\/li>\n<\/ol>\n<p>Der schwierigste Teil ist oft die Umgebung, nicht der Code. Investieren Sie fr\u00fchzeitig in reproduzierbaren Setup, und parallele Simulationen lassen sich einfacher von Laptop zu Supercomputer skalieren.<\/p>\n<h3>N\u00e4chste Schritte<\/h3>\n<ol>\n<li>\u00dcberpr\u00fcfen Sie die aktuelle Simulation. Wenn es nur auf einem Laptop ausgef\u00fchrt wird, erstellen Sie zun\u00e4chst eine Conda-Umgebung und testen Sie einen kleinen Multi-Core-Lauf.<\/li>\n<li>Messen Sie vor der Skalierung. F\u00fchren Sie einen kleinen Cluster-Job aus, messen Sie die Beschleunigung und skalieren Sie erst dann auf die Produktionsgr\u00f6\u00dfe.<\/li>\n<li>Dokumentieren Sie die Einrichtung. Speichern Sie die Umgebungsdatei, das Auftragsskript, den Startbefehl und die erwartete Ausgabe.<\/li>\n<\/ol>\n<p>Das Einrichten eines HPC-Python-Workflows erfordert das Verst\u00e4ndnis von Python-Wissenschaftspaketen, paralleler Programmierung und Cluster-Infrastruktur. Wenn Sie Hilfe bei der Parallelisierung von MPI, der Jobplanung oder der Reproduzierbarkeit der Umgebung ben\u00f6tigen, kann unser Team skalierbare wissenschaftliche Python-Workflows unterst\u00fctzen, einschlie\u00dflich FIPY-basierter Simulationen und benutzerdefinierten Monte-Carlo-Motoren.<\/p>\n","protected":false,"raw":"<h2>Schl\u00fcssel zum Mitnehmen<\/h2>\n<ul>\n<li>Python-Code kann auf einem Laptop und einem gro\u00dfen HPC-System mit der gleichen Kernlogik ausgef\u00fchrt werden, wenn der Workflow MPI4Py oder Dask korrekt verwendet.<\/li>\n<li>Die Reproduzierbarkeit der Umgebung ist oft der schwierigste Teil der HPC-Arbeit. Conda-Umgebungen, Lockfiles und Job-Skripte helfen dabei, es zu l\u00f6sen.<\/li>\n<li>Der Workflow besteht aus drei Phasen: Prototyp lokal, parallelisieren mit MPI4PY oder DASK und Senden von Jobs \u00fcber SLURM, PBS oder einen anderen Scheduler.<\/li>\n<li>Schreiben Sie nicht die gesamte Codebasis f\u00fcr den Cluster neu. Halten Sie die Simulationslogik stabil und wickeln Sie sie mit reproduzierbarer Umgebung und parallelen Ausf\u00fchrungsschichten ein.<\/li>\n<\/ul>\n<p>Sie schreiben ein Simulationsskript auf Ihren Laptop. Sie testen es mit kleinen Datens\u00e4tzen. Es l\u00e4uft in Minuten. Dann ben\u00f6tigen Sie Tausende von Kernen und Hunderte von Gigabyte RAM, um es im Ma\u00dfstab auszuf\u00fchren.<\/p>\n<p>Schreiben Sie die gesamte Codebasis um?<\/p>\n<p>Nein. Der gleiche Python-Code, der auf Ihrem Laptop ausgef\u00fchrt wird, kann auf einem Supercomputer mit minimalen \u00c4nderungen ausgef\u00fchrt werden. Der Schl\u00fcssel ist nicht neu zu schreiben. es ist umwickelt.<\/p>\n<p>Sie ben\u00f6tigen drei Dinge: eine reproduzierbare Umgebung, ein paralleles Ausf\u00fchrungsmodell und ein Auftrags\u00fcbermittlungsskript f\u00fcr den Clusterplaner.<\/p>\n<p>Dieser Leitfaden durchl\u00e4uft den vollst\u00e4ndigen Workflow vom lokalen Prototyp bis zur HPC-Produktion, ohne dass Sie Ihre Kernsimulationslogik \u00e4ndern.<\/p>\n<h2>Der dreistufige HPC-Python-Workflow<\/h2>\n<p>Die meisten HPC-Python-Projekte folgen unabh\u00e4ngig vom wissenschaftlichen Bereich dem gleichen dreistufigen Muster.<\/p>\n<pre><code>Stage 1 \u2014 Local Prototyping:\n  Laptop \u2192 Jupyter or IDE \u2192 NumPy \/ Pandas \u2192 serial execution\n\nStage 2 \u2014 Parallelization:\n  Same code \u2192 mpi4py or Dask \u2192 parallel execution\n\nStage 3 \u2014 Cluster Deployment:\n  Python script \u2192 Slurm \/ PBS job submission \u2192 distributed compute nodes\n<\/code><\/pre>\n<p>Ziel ist es, diese Phasen schrittweise durchzugehen. Beginnen Sie mit einer funktionierenden lokalen Version. F\u00fcgen Sie die parallele Ausf\u00fchrung erst hinzu, wenn die Logik korrekt ist. Erst nach kleinen parallelen Tests an den Cluster senden.<\/p>\n<h2>Stufe 1: Aufbau einer reproduzierbaren Umgebung<\/h2>\n<p>Bevor Sie parallelen Code schreiben, ben\u00f6tigen Sie eine zuverl\u00e4ssige Entwicklungsumgebung. Hier scheitern viele wissenschaftliche Workflows zuerst.<\/p>\n<h3>Warum Reproduzierbarkeit f\u00fcr HPC-Cluster schwierig ist<\/h3>\n<p>HPC-Cluster sind gemeinsam genutzte Systeme. Viele Forschungsgruppen verwenden dieselbe Infrastruktur, und Systempakete k\u00f6nnen sich im Laufe der Zeit \u00e4ndern. Eine heutige Simulation kann nach Modulaktualisierungen, Compiler\u00e4nderungen oder Paketversions\u00e4nderungen sechs Monate sp\u00e4ter abbrechen.<\/p>\n<p>Die L\u00f6sung ist das Umweltmanagement. Conda wird h\u00e4ufig verwendet, weil es Pakete aus dem System Python isoliert und sowohl kompilierte Abh\u00e4ngigkeiten als auch Python-Pakete verwalten kann.<\/p>\n<pre><code class=\"language-bash\"># Create a reproducible environment\nconda create -n my-sim python=3.11 numpy mpi4py dask\n\n# Lock dependencies for reproducibility\nconda env export --no-builds --name my-sim &gt; environment.yml\n\n# Recreate the environment on another machine\nconda env create -n my-sim -f environment.yml\n<\/code><\/pre>\n<p>Eine einzelne Umgebungsdatei bietet Mitarbeitern und zuk\u00fcnftigen Benutzern eine klare M\u00f6glichkeit, den Software-Stack neu zu erstellen. Verwenden Sie f\u00fcr eine strengere Reproduzierbarkeit Lockfiles, die jede Paketversion anheften und eine Abh\u00e4ngigkeit aufbauen.<\/p>\n<h3>Conda vs Venv: Warum Conda oft auf HPC gewinnt<\/h3>\n<p>Pythons integrierte <code>venv<\/code>  funktioniert gut f\u00fcr reine Python-Pakete. HPC-Workflows h\u00e4ngen h\u00e4ufig von kompilierten wissenschaftlichen Bibliotheken, MPI-Runtimes, HDF5, BLAS, CUDA und anderen Komponenten auf Systemebene ab.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Funktion<\/th>\n<th>Venv<\/th>\n<th>Konda<\/th>\n<\/tr>\n<tr>\n<td>Reine Python-Pakete<\/td>\n<td>Ja<\/td>\n<td>Ja<\/td>\n<\/tr>\n<tr>\n<td>Abh\u00e4ngigkeiten auf Systemebene wie MPI und HDF5<\/td>\n<td>Nein<\/td>\n<td>Ja<\/td>\n<\/tr>\n<tr>\n<td>Plattform\u00fcbergreifende Konsistenz<\/td>\n<td>Beschr\u00e4nkt<\/td>\n<td>Stark<\/td>\n<\/tr>\n<tr>\n<td>GPU-Beschleunigungspakete wie Cupy oder PyTorch CUDA<\/td>\n<td>Manuelle Einrichtung<\/td>\n<td>Mehr automatisierte Einrichtung<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Conda bietet Reproduzierbarkeit \u00fcber mehr wissenschaftliche Stapel. Das ist bei der Arbeit mit MPI4Py von Bedeutung, da die MPI-Runtime- und Python-Umgebung sowohl auf dem lokalen Computer als auch auf dem Cluster kompatibel sein muss.<\/p>\n<h2>Stufe 2: Parallelisierung Ihres Python-Codes<\/h2>\n<p>Sobald die lokale Version funktioniert, ist der n\u00e4chste Schritt die Parallelisierung. In Python-HPC-Workflows sind zwei Tools besonders verbreitet:<\/p>\n<ol>\n<li>MPI4PY f\u00fcr eine feink\u00f6rnige verteilte Steuerung \u00fcber viele Knoten.<\/li>\n<li>Dask f\u00fcr \u00fcbergeordnete Parallelit\u00e4t mit weniger Code\u00e4nderungen.<\/li>\n<\/ol>\n<h3>Warum Sie mpi4py brauchen<\/h3>\n<p>Die globale Dolmetschersperre von Python begrenzt die wahre Multi-Thread-Python-Ausf\u00fchrung in einem Prozess. Das <code>multiprocessing<\/code>-Modul kann auf einer Maschine parallelisieren, skaliert jedoch nicht \u00fcber mehrere Rechenknoten hinweg.<\/p>\n<p>MPI4PY bietet Python-Bindungen f\u00fcr MPI, die Nachrichten\u00fcbermittlungsschnittstelle. MPI ist eine Standard-API f\u00fcr verteiltes Parallel-Computing und wird h\u00e4ufig auf HPC-Systemen verwendet.<\/p>\n<p>Bei MPI4Py f\u00fchrt jeder Prozess das gleiche Skript aus, erh\u00e4lt jedoch einen eindeutigen Rang. Dieser Rang steuert, welchen Teil der Arbeitslast jeder Prozess verarbeitet.<\/p>\n<h3>Grundlegendes mpi4py-Muster: Hallo Welt<\/h3>\n<pre><code class=\"language-python\">from mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\nprint(f\"Hello from process {rank} out of {size} processes\")\n<\/code><\/pre>\n<p>Starten Sie das Skript mit MPI:<\/p>\n<pre><code class=\"language-bash\">mpiexec -n 16 python my_script.py\n<\/code><\/pre>\n<p>Dies startet 16 unabh\u00e4ngige Python-Prozesse. Jeder Prozess f\u00fchrt das gleiche Skript aus, aber jeder hat ein anderes <code>rank<\/code> .<\/p>\n<h3>Das Datenmodell: unabh\u00e4ngige Prozesse<\/h3>\n<p>MPI-Prozesse teilen sich standardm\u00e4\u00dfig keinen Speicher. Jeder Prozess hat seinen eigenen Speicherplatz. Um Informationen auszutauschen, m\u00fcssen Prozesse explizit Daten senden, empfangen, \u00fcbertragen, sammeln oder verkleinern.<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\n\n# Rank 0 creates the initial data.\nif rank == 0:\n    data = np.arange(10, dtype=\"i\")\nelse:\n    data = np.empty(10, dtype=\"i\")\n\n# Broadcast data from rank 0 to all ranks.\ncomm.Bcast(data, root=0)\n\nprint(f\"Rank {rank} received data: {data}\")\n<\/code><\/pre>\n<p>Dieses explizite Kommunikationsmodell ist ein Grund, warum MPI gut skaliert. Jeder Rang besitzt seinen lokalen Speicher, und die Kommunikation erfolgt nur, wenn Sie ihn anfordern.<\/p>\n<h3>Workload-Verteilung: Das Kernmuster<\/h3>\n<p>Die meisten wissenschaftlichen MPI-Workflows folgen demselben Muster: Teilen Sie das Problem, berechnen Sie lokal und reduzieren Sie die Ergebnisse.<\/p>\n<pre><code class=\"language-python\">from mpi4py import MPI\nimport numpy as np\n\ncomm = MPI.COMM_WORLD\n\nsize = comm.Get_size()\nrank = comm.Get_rank()\n\n# Total problem size\nN = 10_000_000\n\n# Calculate workload per rank\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\n# Each rank works on its own slice\nmy_data = np.random.rand(my_end - my_start)\n\n# Local computation\nlocal_result = np.sum(np.sin(my_data))\n\n# Sum results across all ranks\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Total computed across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<p>Dieses Muster gilt f\u00fcr viele Simulationsaufgaben:<\/p>\n<ul>\n<li>Monte-Carlo-Simulationen, bei denen jeder Rang unabh\u00e4ngige Stichproben verarbeitet.<\/li>\n<li>Parameter-Sweeps, bei denen jeder Rang verschiedene Parameters\u00e4tze testet.<\/li>\n<li>Dom\u00e4nenzerlegung, wobei jeder Rang einen Teil des Simulationsrasters besitzt.<\/li>\n<li>Molekulare Dynamik, bei der die Rechenkr\u00e4fte f\u00fcr verschiedene Teilchen-Teilmengen rangieren.<\/li>\n<\/ul>\n<h3>Die kollektive Kommunikations-Toolbox<\/h3>\n<p>MPI4Py bietet kollektive Vorg\u00e4nge, die in der Regel einfacher und effizienter sind als benutzerdefinierte Punkt-zu-Punkt-Messaging.<\/p>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Betrieb<\/th>\n<th>Was es tut<\/th>\n<th>Wann zu verwenden<\/th>\n<\/tr>\n<tr>\n<td><code>Bcast<\/code><\/td>\n<td>Ein Prozess sendet die gleichen Daten an alle R\u00e4nge<\/td>\n<td>Teilen von Anfangsbedingungen, Konstanten oder Konfigurationswerten<\/td>\n<\/tr>\n<tr>\n<td><code>Scatter<\/code><\/td>\n<td>Verteilt Teile eines Arrays \u00fcber R\u00e4nge<\/td>\n<td>Dom\u00e4nenzerlegung oder Workload-Partitionierung<\/td>\n<\/tr>\n<tr>\n<td><code>Gather<\/code><\/td>\n<td>Sammelt Daten aus allen Reihen<\/td>\n<td>Sammeln von Teilausgaben<\/td>\n<\/tr>\n<tr>\n<td><code>Reduce<\/code><\/td>\n<td>Aggregiert Werte wie SUM, MAX oder MIN<\/td>\n<td>Energien summieren oder globale Metriken sammeln<\/td>\n<\/tr>\n<tr>\n<td><code>Allreduce<\/code><\/td>\n<td>Aggregiert Werte und gibt jedem Rang das Ergebnis<\/td>\n<td>Synchronisieren des globalen Status \u00fcber alle Prozesse<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Verwenden Sie nach M\u00f6glichkeit kollektive Kommunikation. Es ist normalerweise einfacher und effizienter als die manuelle Koordinierung vieler Sends und Empfangen.<\/p>\n<h3>Wann sollte man das stattdessen verwenden?<\/h3>\n<p>Dask sitzt zwischen Serial Python und MPI. Dies ist n\u00fctzlich, wenn die Arbeitslast peinlich parallel ist, z. B. die gleiche Simulation mit vielen Parameters\u00e4tzen oder Anfangsbedingungen auszuf\u00fchren.<\/p>\n<pre><code class=\"language-python\">from dask.distributed import Client\nfrom dask import delayed\n\nclient = Client(n_workers=16, threads_per_worker=4)\n\ndef my_simulation(params):\n    # Your simulation logic here\n    return params[\"a\"] * params[\"b\"]\n\nparameter_list = [\n    {\"a\": i, \"b\": 2.0}\n    for i in range(100)\n]\n\ntasks = [\n    delayed(my_simulation)(params)\n    for params in parameter_list\n]\n\nfinal_results = client.compute(tasks, sync=True)\n\nprint(final_results[:5])\n<\/code><\/pre>\n<p>Der Vorteil von Dask ist, dass Sie viele Workflows parallelisieren k\u00f6nnen, ohne die Simulation um R\u00e4nge und Kommunikatoren neu zu gestalten.<\/p>\n<h3>mpi4py vs. Dask: Welche w\u00e4hlen?<\/h3>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Kriterium<\/th>\n<th>MPI4PY<\/th>\n<th>Dask<\/th>\n<\/tr>\n<tr>\n<td>Lernkurve<\/td>\n<td>Steiler, weil Sie R\u00e4nge und Kommunikatoren verstehen m\u00fcssen<\/td>\n<td>sanfter, weil es bekannte Python-Aufgabenmuster verwendet<\/td>\n<\/tr>\n<tr>\n<td>Feinkornsteuerung<\/td>\n<td>Ausgezeichnet, weil jede Kommunikation explizit ist<\/td>\n<td>Eingeschr\u00e4nkt durch die Aufgabengrafik-Abstraktion<\/td>\n<\/tr>\n<tr>\n<td>Speichereffizienz<\/td>\n<td>Hoch, weil jeder Rang sein eigenes St\u00fcck speichert<\/td>\n<td>gem\u00e4\u00dfigt, weil die Arbeitnehmer den Overhead erh\u00f6hen<\/td>\n<\/tr>\n<tr>\n<td>Passend f\u00fcr<\/td>\n<td>Gro\u00dfformatige PDE-Solver und dom\u00e4nenzerlegte Simulationen<\/td>\n<td>Monte Carlo, Parameter-Sweeps und Datenanalyse<\/td>\n<\/tr>\n<tr>\n<td>Beste Skala<\/td>\n<td>Dichte Parallelit\u00e4t \u00fcber viele Knoten<\/td>\n<td>Schwache Skalierung \u00fcber m\u00e4\u00dfige Arbeiterz\u00e4hlungen<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Beginnen Sie mit DASK f\u00fcr Prototyping und peinlich parallele Workloads. Gehen Sie zu MPI4PY, wenn Sie \u00fcber viele Knoten hinweg eine strenge Kontrolle \u00fcber Kommunikation, Speicher und Skalierung ben\u00f6tigen.<\/p>\n<h2>Stufe 3: Einreichen des Clusters<\/h2>\n<p>Nach lokalem Testen und Parallelisierung ist der n\u00e4chste Schritt die Clusterbereitstellung. Die meisten Cluster verwenden einen Jobplaner. Slurm ist eine der h\u00e4ufigsten.<\/p>\n<h3>Das Slurm-Job-Skript<\/h3>\n<p>Ein Slurm-Job-Skript teilt dem Scheduler mit, welche Ressourcen Sie ben\u00f6tigen und wie der Code ausgef\u00fchrt wird.<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=my-sim\n#SBATCH --nodes=32\n#SBATCH --tasks-per-node=4\n#SBATCH --cpus-per-task=1\n#SBATCH --mem=8GB\n#SBATCH --time=04:00:00\n#SBATCH --output=sim_output.%j\n\n# Load required modules\nmodule load Python\/3.11\n\n# Activate conda environment\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\n# Run the MPI job\nsrun python my_simulation.py\n<\/code><\/pre>\n<p>Wichtige Parameter sind:<\/p>\n<ul>\n<li><code>--nodes<\/code>: Anzahl der Rechenknoten.<\/li>\n<li><code>--tasks-per-node<\/code>: Anzahl der MPI-Aufgaben pro Knoten.<\/li>\n<li><code>--cpus-per-task<\/code>: CPU-Kernen, die jeder Aufgabe zugewiesen werden.<\/li>\n<li><code>--time<\/code>: Wanduhrgrenze. Jobs werden normalerweise gestoppt, wenn sie es \u00fcberschreiten.<\/li>\n<li><code>--output<\/code>: Ausgabedateimuster. <code>%j<\/code> F\u00fcgt die Job-ID ein.<\/li>\n<\/ul>\n<h3>Laufen auf Clustern ohne Slurm<\/h3>\n<p>Nicht jeder Cluster verwendet Slurm. H\u00e4ufige Alternativen sind:<\/p>\n<ul>\n<li>PBS oder Drehmoment, normalerweise unter Verwendung von <code>qsub<\/code> .<\/li>\n<li>LSF, normalerweise mit <code>bsub<\/code> .<\/li>\n<li>Kobalt oder andere ortsspezifische Scheduler.<\/li>\n<\/ul>\n<p>Die Syntax der Jobeinreichung \u00e4ndert sich, der Python-Code jedoch normalerweise nicht. MPI4PY und DASK sind meist planer-agnostisch, sobald sie korrekt gestartet wurden.<\/p>\n<h3>Interaktiver vs. Batch-Modus<\/h3>\n<p>Zum Debuggen sind interaktive L\u00e4ufe n\u00fctzlich:<\/p>\n<pre><code class=\"language-bash\">srun --ntasks=4 --pty --time=02:00:00 python my_simulation.py\n<\/code><\/pre>\n<p>Verwenden Sie f\u00fcr die Produktion die Chargeneinreichung:<\/p>\n<pre><code class=\"language-bash\">sbatch my_job_script.sh\n<\/code><\/pre>\n<p>Interaktive Sitzungen eignen sich gut f\u00fcr kurze Tests. Batch-Jobs sind besser f\u00fcr Langstrecken, Arbeitslasten \u00fcber Nacht und Produktionssimulationen.<\/p>\n<h2>Der komplette Workflow: vom Laptop bis zur Produktion<\/h2>\n<p>Der \u00dcbergang vom lokalen Prototyp zur Clusterbereitstellung kann allm\u00e4hlich erfolgen. Die Kernsimulationslogik sollte stabil bleiben, w\u00e4hrend sich der Ausf\u00fchrungswrapper \u00e4ndert.<\/p>\n<h3>Schritt 1: Entwickeln und testen Sie lokal<\/h3>\n<pre><code class=\"language-python\"># my_simulation.py\nimport numpy as np\n\ndef simulate(initial_condition, params):\n    # Core simulation logic\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\n# Local test\ndata = np.random.rand(1000)\nresult = simulate(data, {\"factor\": 1.5})\n\nprint(f\"Local result: {result}\")\n<\/code><\/pre>\n<h3>Schritt 2: Parallelisierung hinzuf\u00fcgen<\/h3>\n<pre><code class=\"language-python\"># my_simulation_mpi.py\nimport numpy as np\nfrom mpi4py import MPI\n\ncomm = MPI.COMM_WORLD\n\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\ndef simulate(initial_condition, params):\n    # Core simulation logic stays the same\n    result = np.sin(initial_condition) * params[\"factor\"]\n    return np.sum(result)\n\nN = 10_000_000\n\nworkloads = [N \/\/ size for _ in range(size)]\n\nfor i in range(N % size):\n    workloads[i] += 1\n\nmy_start = sum(workloads[:rank])\nmy_end = my_start + workloads[rank]\n\nmy_data = np.random.rand(my_end - my_start)\n\nlocal_result = simulate(my_data, {\"factor\": 1.5})\n\nsend_buffer = np.array([local_result])\nreceive_buffer = np.zeros(1)\n\ncomm.Reduce(send_buffer, receive_buffer, op=MPI.SUM, root=0)\n\nif rank == 0:\n    print(f\"Parallel result across {size} ranks: {receive_buffer[0]}\")\n<\/code><\/pre>\n<h3>Schritt 3: An den Cluster senden<\/h3>\n<p>Speichern Sie ein Job-Skript wie <code>job_script.sh<\/code>:<\/p>\n<pre><code class=\"language-bash\">#!\/bin\/bash\n#SBATCH --job-name=parallel-sim\n#SBATCH --nodes=64\n#SBATCH --tasks-per-node=8\n#SBATCH --time=12:00:00\n\nmodule load Python\/3.11\n\neval \"$(conda shell.bash hook)\"\nconda activate my-sim\n\nsrun python my_simulation_mpi.py\n<\/code><\/pre>\n<p>einreichen:<\/p>\n<pre><code class=\"language-bash\">sbatch job_script.sh\n<\/code><\/pre>\n<p>Die Simulationslogik bleibt gleich. Der Wrapper \u00e4ndert die Aufteilung und den Start der Arbeitslast.<\/p>\n<h2>H\u00e4ufige Fallstricke und wie man sie vermeidet<\/h2>\n<h3>Fallfall 1: Zu viele Daten \u00fcbertragen<\/h3>\n<p>Das Senden gro\u00dfer Arrays von Rang 0 bis zu jedem Rang kann zu einem Kommunikationsengpass werden. Vermeiden Sie bei gro\u00dfen Simulationen, mehr Daten zu senden, als jeder Rang ben\u00f6tigt.<\/p>\n<p>Bessere Optionen sind:<\/p>\n<ul>\n<li>Verwenden Sie <code>Scatter<\/code> anstelle von <code>Bcast<\/code>, wenn jeder Rang nur eine Scheibe ben\u00f6tigt.<\/li>\n<li>Verwenden Sie die Dom\u00e4nenzerlegung, damit jeder Rang eine Region der Simulation besitzt.<\/li>\n<li>Lassen Sie f\u00fcr Monte Carlo jeden Rang seine eigenen Zufallsstichproben generieren, anstatt sie zu senden.<\/li>\n<\/ul>\n<h3>Fallstricke 2: \u00dcberalloverallcluster-Ressourcen<\/h3>\n<p>Wenn Sie mehr Knoten als Ihr Code anfordern, k\u00f6nnen Sie Zeit f\u00fcr die Zuweisung von Abf\u00e4llen verwenden und die Warteschlangenverz\u00f6gerung erh\u00f6hen.<\/p>\n<p>Beginnen Sie mit einem kleinen Testjob, z. B. 4 bis 8 Knoten. Beschleunigung messen. Skalieren erst, nachdem der Code n\u00fctzliche parallele Effizienz zeigt.<\/p>\n<h3>Fallfall 3: Vergessen der Gil in gemischtem Code<\/h3>\n<p>Numpy, Scipy und kompilierte C- oder Fortran-Bibliotheken geben h\u00e4ufig die Python-Global-Interpreter-Sperre w\u00e4hrend schwerer numerischer Operationen frei. Reine Python-Threads bieten normalerweise nicht den gleichen Nutzen.<\/p>\n<p>Wenn Ihr Workflow Python-Threads mit numerischen Bibliotheken mischt, hilft die Testskalierung sorgf\u00e4ltig, anstatt mehr Threads anzunehmen.<\/p>\n<h3>Fallfall 4: Umgebungsfehler auf dem Cluster<\/h3>\n<p>Ihr Laptop kann Python 3.11 verwenden, w\u00e4hrend das Clustermodul Python 3.9 bereitstellt. MPI4PY, MPI-Bibliotheken und kompilierte Abh\u00e4ngigkeiten k\u00f6nnen brechen, wenn Versionen nicht \u00fcbereinstimmen.<\/p>\n<p>Verwenden Sie eine Conda-Umgebung und dokumentieren Sie die genaue Einrichtung. Erstellen und testen Sie die Umgebung auf dem Cluster, bevor Sie gro\u00dfe Jobs ausf\u00fchren.<\/p>\n<h2>Entscheidungsleitfaden: Welche Parallelisierungsstrategie?<\/h2>\n<table class=\"custom-table\">\n<tbody><tr>\n<th>Lage<\/th>\n<th>Empfohlener Ansatz<\/th>\n<\/tr>\n<tr>\n<td>Kleiner Datensatz und lokale Logiktests<\/td>\n<td>Serienpython mit numpy<\/td>\n<\/tr>\n<tr>\n<td>Einzelmaschine mit mehreren Kernen<\/td>\n<td>Python <code>multiprocessing<\/code> oder Dask <code>LocalCluster<\/code><\/td>\n<\/tr>\n<tr>\n<td>8\u201364 Arbeiter und peinlich parallele Aufgaben<\/td>\n<td>Dask mit einem Cluster-Launcher<\/td>\n<\/tr>\n<tr>\n<td>64\u20131000 Knoten und dom\u00e4nenzerlegte PDEs<\/td>\n<td>mpi4py mit expliziter Workload-Verteilung<\/td>\n<\/tr>\n<tr>\n<td>Produktionssimulation auf \u00fcber 1000 Knoten<\/td>\n<td>MPI4PY, Scheduler-Job-Skripte und gesperrte Conda-Umgebung<\/td>\n<\/tr>\n<tr>\n<td>Recherchecode ohne garantierte Reproduzierbarkeit<\/td>\n<td>Dask, Conda-Umgebungsdatei und Job-Skript als Ausgangspunkt<\/td>\n<\/tr>\n<\/tbody><\/table>\n<p>Ihr Parallelisierungstool sollte mit dem Ma\u00dfstab und der Struktur des Problems \u00fcbereinstimmen. Beginnen Sie kleiner als Sie denken und skalieren Sie nach der Messung der Leistung.<\/p>\n<h2>Verwandte Anleitungen<\/h2>\n<p>Zu verwandten Themen in wissenschaftlichen Simulations-Workflows:<\/p>\n<ul>\n<li><a href=\"https:\/\/matforge.org\/gpu-acceleration-for-fipy-simulations-cupy-and-numba-integration-guide\/\">GPU-Beschleunigung f\u00fcr FIPY-Simulationen: Cupy- und Numba-Integrationshandbuch<\/a> \u2014 Wenn parallele CPU ist nicht genug.<\/li>\n<li><a href=\"https:\/\/matforge.org\/performance-profiling-optimization-python-pde-solvers\/\">Leistungsprofilierung und -optimierung f\u00fcr Python-PDE-Solver: Ein praktischer Leitfaden <\/a> - Finden von Engp\u00e4ssen vor der Parallelisierung.<\/li>\n<li><a href=\"https:\/\/matforge.org\/python-debugging-scientific-code-print-statements-profiling\/\"> Python-Debugging f\u00fcr wissenschaftlichen Code: Von Druckanweisungen bis Profiling <\/a> - Debuggen von parallelen Simulationen.<\/li>\n<\/ul>\n<h2>Zusammenfassung und n\u00e4chste Schritte<\/h2>\n<p>Bei HPC-Python-Workflows geht es um das Einpacken, nicht um das Umschreiben. Die gleiche Simulationslogik, die auf einem Laptop ausgef\u00fchrt wird, kann auf vielen Kernen ausgef\u00fchrt werden, wenn Sie die richtige Ausf\u00fchrungsstruktur erstellen.<\/p>\n<p>Der Arbeitsablauf ist:<\/p>\n<ol>\n<li>Sperren Sie die Umgebung mit Conda, damit der Code konsistent \u00fcber alle Systeme l\u00e4uft.<\/li>\n<li>F\u00fcgen Sie Parallelit\u00e4t mit MPI4PY f\u00fcr eine feink\u00f6rnige verteilte Steuerung oder einen Stab f\u00fcr die Parallelit\u00e4t von Aufgaben hinzu.<\/li>\n<li>Senden Sie Jobs \u00fcber Slurm, PBS, LSF oder den von Ihrem Cluster verwendeten Scheduler.<\/li>\n<\/ol>\n<p>Der schwierigste Teil ist oft die Umgebung, nicht der Code. Investieren Sie fr\u00fchzeitig in reproduzierbaren Setup, und parallele Simulationen lassen sich einfacher von Laptop zu Supercomputer skalieren.<\/p>\n<h3>N\u00e4chste Schritte<\/h3>\n<ol>\n<li>\u00dcberpr\u00fcfen Sie die aktuelle Simulation. Wenn es nur auf einem Laptop ausgef\u00fchrt wird, erstellen Sie zun\u00e4chst eine Conda-Umgebung und testen Sie einen kleinen Multi-Core-Lauf.<\/li>\n<li>Messen Sie vor der Skalierung. F\u00fchren Sie einen kleinen Cluster-Job aus, messen Sie die Beschleunigung und skalieren Sie erst dann auf die Produktionsgr\u00f6\u00dfe.<\/li>\n<li>Dokumentieren Sie die Einrichtung. Speichern Sie die Umgebungsdatei, das Auftragsskript, den Startbefehl und die erwartete Ausgabe.<\/li>\n<\/ol>\n<p>Das Einrichten eines HPC-Python-Workflows erfordert das Verst\u00e4ndnis von Python-Wissenschaftspaketen, paralleler Programmierung und Cluster-Infrastruktur. Wenn Sie Hilfe bei der Parallelisierung von MPI, der Jobplanung oder der Reproduzierbarkeit der Umgebung ben\u00f6tigen, kann unser Team skalierbare wissenschaftliche Python-Workflows unterst\u00fctzen, einschlie\u00dflich FIPY-basierter Simulationen und benutzerdefinierten Monte-Carlo-Motoren.<\/p>\n"},"excerpt":{"rendered":"<p><span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 8<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>Schl\u00fcssel zum Mitnehmen Python-Code kann auf einem Laptop und einem gro\u00dfen HPC-System mit der gleichen Kernlogik ausgef\u00fchrt werden, wenn der Workflow MPI4Py oder Dask korrekt verwendet. Die Reproduzierbarkeit der Umgebung ist oft der schwierigste Teil der HPC-Arbeit. Conda-Umgebungen, Lockfiles und Job-Skripte helfen dabei, es zu l\u00f6sen. Der Workflow besteht aus drei Phasen: Prototyp lokal, parallelisieren [&hellip;]<\/p>\n","protected":false,"raw":""},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"de_DE","_original_post":"https:\/\/matforge.org\/?p=341","iawp_total_views":0,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-879","post","type-post","status-publish","format-standard","hentry","category-simulation-modeling-projects","de-DE"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>HPC-Python-Workflows-Handbuch<\/title>\n<meta name=\"description\" content=\"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"HPC-Python-Workflows-Handbuch\" \/>\n<meta property=\"og:description\" content=\"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-30T12:23:24+00:00\" \/>\n<meta name=\"author\" content=\"Elena Markovska\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Elena Markovska\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"13\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"author\":{\"name\":\"Elena Markovska\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"headline\":\"HPC-Python-Workflows: Vom Laptop zum Supercomputer\",\"datePublished\":\"2026-07-30T12:23:24+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"},\"wordCount\":1951,\"commentCount\":0,\"articleSection\":[\"Simulation & amp; Modellierungsprojekte\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\",\"name\":\"HPC-Python-Workflows-Handbuch\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-07-30T12:23:24+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\"},\"description\":\"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/hpc-python-workflows-from-laptop-to-supercomputer\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"HPC-Python-Workflows: Vom Laptop zum Supercomputer\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\",\"url\":\"https:\\\/\\\/matforge.org\\\/\",\"name\":\"matforge.org\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/matforge.org\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/980162bb5de46742daece973661d93da\",\"name\":\"Elena Markovska\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g\",\"caption\":\"Elena Markovska\"},\"sameAs\":[\"http:\\\/\\\/matforge.org\"],\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/elena-markovska\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"HPC-Python-Workflows-Handbuch","description":"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_locale":"de_DE","og_type":"article","og_title":"HPC-Python-Workflows-Handbuch","og_description":"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.","og_url":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/","og_site_name":"matforge.org","article_published_time":"2026-07-30T12:23:24+00:00","author":"Elena Markovska","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Elena Markovska","Gesch\u00e4tzte Lesezeit":"13\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"author":{"name":"Elena Markovska","@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"headline":"HPC-Python-Workflows: Vom Laptop zum Supercomputer","datePublished":"2026-07-30T12:23:24+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/"},"wordCount":1951,"commentCount":0,"articleSection":["Simulation & amp; Modellierungsprojekte"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/","url":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/","name":"HPC-Python-Workflows-Handbuch","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-07-30T12:23:24+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da"},"description":"Erfahren Sie, wie Sie Python-Simulationen von Laptop zu HPC-Clustern verschieben, indem Sie Conda-, MPI4Py-, DASK-, Slurm- und reproduzierbare Job-Skripte verwenden.","breadcrumb":{"@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/de\/hpc-python-workflows-from-laptop-to-supercomputer\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/de\/"},{"@type":"ListItem","position":2,"name":"HPC-Python-Workflows: Vom Laptop zum Supercomputer"}]},{"@type":"WebSite","@id":"https:\/\/matforge.org\/#website","url":"https:\/\/matforge.org\/","name":"matforge.org","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/matforge.org\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/980162bb5de46742daece973661d93da","name":"Elena Markovska","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2de4e35b6581d7d8a839335156c6b5834cfaa0aef537a1c837e882dc57eea1e7?s=96&d=mm&r=g","caption":"Elena Markovska"},"sameAs":["http:\/\/matforge.org"],"url":"https:\/\/matforge.org\/author\/elena-markovska\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/879","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=879"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/879\/revisions"}],"predecessor-version":[{"id":1029,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/879\/revisions\/1029"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=879"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=879"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=879"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}