Das deutsche Python-Forum

Hallo, ich habe nun meinen Code, bestehend aus 3 binären Programmteilen und mehreren ineinander greifenden Input und Output Files, zum Laufen gebracht. Ein erster Testlauf hat gezeigt, dass ich 1,3 Berechnungsläufe in der Sekunde schaffe, das ist mir jedoch für die geplanten 500tsd Rechenschritte weit zu langsam. Um die Performance zu steigern habe ich nun folgendes angestrebt:

Version 1:
Kopieren des Ordners mit sämtlichen Files auf in Summe 20 Stück (Ordner01, Ordner02,...) Anpassen der Parametersets, sodass je Ordner jeweils nur ca. 5000 Rechenvorgänge stattfinden = ca. 1 Stunde Rechenlauf und 50 Ordner. Starten des Skript jeweils im Terminal.

Version 2:
durch: usw. habe ich die jeweiligen ca. 5000tsd Berechnungsschritte in definiert als zB def iteration_01(): "Berechnungsschritte" die jeweils in den entsprechenden Ordner zugreifen, jedoch ohne Erfolg, da scheinbar diese Prozesse nicht parallel verlaufen

Version 3:
Führte mich zu threading (Python 3), wobei ich hier komplett hänge.

Konkrete Fragestellung:
über zB. 50 def Positionen möchte ich die Laufzeit für den bereits erfolgreich durchlaufenden Berechnungslauf mittels parallel automatisch laufenden Berchnungsläufen verkürzen. Ist da eurer Meinung nach meine Version 2, oder 3 die Richtigere oder bin ich sowieso auf einem falschen Weg, wenn ja, bitte um einen Gedankenanstoß.

Danke

@fox1203: Threading läuft zumindest unter CPython in Python-Bytecode nicht parallel. Multiprocessing macht da mehr Sinn.

Die nummerierten `iteration_*`-Funktionen sehen nicht sinnvoll aus. Wobei die drei Prozesse parallel laufen. Wie kommst Du darauf sie täten das nicht? Allerdings so wie es da steht nicht unter Windows. *Da* wird bei dem Code noch *viel* mehr parallel laufen, das ist quasi so was wie eine „fork bomb“. Witzigerweise weil es `fork()` unter Windows *nicht* gibt.

Hier ist wirklich wichtig, dass man auf Modulebene keinen Code hat, ausser solchen der Konstanten, Funktionen, und Klassen definiert und das Hauptprogramm durch ein ``if __name__ == "__main__":`` schützt.

Man könnte auch noch einen Blick auf `concurrent.futures` und einen Pool von dort werfen. Man kann sich aussuchen ob man damit dann Threads oder Prozesse verwenden will, und die Arbeitseinheiten auch kleiner wählen und dann den Pool das auf Arbeitsthreads oder -Prozesse aufteilen lassen.

mega, jetzt dürft ich wohl schon richtig in python angekommen sein, wenn selbst alte hasen grübeln

also vorweg der code läuft unter Fedora32, da dies neben CentOS die einzige Plattform ist, für welche ich "libgfortran.so.1" finden konnte, eine libary für die etwas ältere Fortran Programmiersprache unter welcher die Binärfiles compiliert wurden.

Zum Parallel Betrieb:
Ich dürfte da einen Tippfehler im Code gehabt haben, es scheint nun doch zu funktionieren mit multiprocessing.

Meintest du die "iteration_XX" Funktionen machen keinen Sinn, weil ich Sie im Code oben nicht angeführt habe?
Sind deine restlichen Anmerkungen nur relevant, wenn man unter Windows den Code ausführt?

Last but not least, danke für die Hilfe!

@fox1203: Die `iteration_*()`-Funktionen sehen falsch aus, auch ohne sie gesehen zu haben, weil man Namen nicht durchnummeriert, und es *sehr* unwahrscheinlich ist, dass es Sinn macht da tatsächlich so viele Funktionen zu schreiben die keine vernünftigen Namen bekommen.

Die restlichen Anmerkungen sind unter jedem Betriebssystem relevant.