Programmiererforum

import numpy as np
import itertools
from multiprocessing import Pool
import MyNumericalProblemSolver

chunksize = 100
n_values_per_param = 50
n_processes = 8
p1_values = np.logspace(1,2,n_values_per_param)
p2_values = np.logspace(3,5,n_values_per_param)
param_iterator = itertools.product(p1_values,p2_values)
solver = MyNumericalProblemSolver()
def wrapper(params):
p1,p2 = params
solver.set_parameters(p1=p1,p2=p2)
solver.solve()

p = Pool(n_processes)
p.map(wrapper,param_iterator,chunksize=chunksize)
< /code>
Die Ausführung des obigen Code dauert normalerweise einige Minuten. Mein Laptop hat 8 CPUs (Ausgabe von Multiprocessing.cpu_count () < /code>). CPU < /li>
[*]n_processes = 1

n_processes = 2

n_processes = 4

n_processes = 8

from multiprocessing import Pool
import numpy as np

matrix_dim = 100
n_processes = 8

def test_function(x):
for i in range(5000):
matrix = np.random.rand(matrix_dim,matrix_dim)
np.linalg.solve(matrix,np.ones(matrix_dim))

n_iter = 100
chunksize = 10
p = Pool(n_processes)
p.map(test_function,range(n_iter),chunksize=chunksize)

142024  Core:0      python
142025  Core:0      python
142026  Core:0      python
142027  Core:0      python
142028  Core:0      python
142029  Core:0      python
142030  Core:0      python
142031  Core:0      python

Ich versuche, die Ausführung eines Python -Codes zu parallelisieren, der ein numerisches Problem löst. Es ist ein relativ komplizierter Code, der Numpy stark benutzt. Ich möchte das numerische Problem für einen großen Satz von Parametern lösen. Dies sollte leicht zu parallelisieren sein: Lassen Sie einfach verschiedene Prozesse das Problem für verschiedene Regionen des Parameterraums lösen.[code]import numpy as np
import itertools
from multiprocessing import Pool
import MyNumericalProblemSolver

chunksize = 100
n_values_per_param = 50
n_processes = 8
p1_values = np.logspace(1,2,n_values_per_param)
p2_values = np.logspace(3,5,n_values_per_param)
param_iterator = itertools.product(p1_values,p2_values)
solver = MyNumericalProblemSolver()
def wrapper(params):
p1,p2 = params
solver.set_parameters(p1=p1,p2=p2)
solver.solve()

p = Pool(n_processes)
p.map(wrapper,param_iterator,chunksize=chunksize)
< /code>
Die Ausführung des obigen Code dauert normalerweise einige Minuten. Mein Laptop hat 8 CPUs (Ausgabe von Multiprocessing.cpu_count () < /code>). CPU < /li>
[*]n_processes = 1[/code]: 1 Prozess verwendet 100% CPU
[*][code]n_processes = 2[/code]: 2 Prozesse, die jeweils 100% CPU
[*] verwenden[code]n_processes = 4[/code]: 4 Prozesse, die jeweils 50% CPU
[*] verwenden[code]n_processes = 8[/code]: 8 Prozesse, jeweils 25% CPU

Es sieht also so aus, als ob die maximale Gesamtnutzung 200% beträgt. Ich verstehe nicht, warum das passiert. Ich habe bestätigt, dass ich beim Starten des Programms ohne Multiprozessierung in 8 verschiedenen Terminals 8 Prozesse mit jeweils 100%erhalte. Dinge, die ich bisher versucht habe: < /p>

Ändern Sie das Chunkize < /code>; Hilft nicht, dass kleine oder große Stückgrößen die gleiche Leistung geben. Multiplikation langsamer). Also habe ich OS.System (f "taskset -p 0xff {os.getPid ()}") ausprobiert, um die CPU -Affinität nach dem [url=viewtopic.php?t=18708]Importieren[/url] von Numpy zurückzusetzen, aber es ändert nichts. Wenn ich os.Sched_getaffinity (0) vor und nach dem [url=viewtopic.php?t=18708]Importieren[/url] von Numphye, erhalte ich die gleiche Ausgabe: {0, 1, 2, 3, 4, 5, 6, 7}.[code]from multiprocessing import Pool
import numpy as np

matrix_dim = 100
n_processes = 8

def test_function(x):
for i in range(5000):
matrix = np.random.rand(matrix_dim,matrix_dim)
np.linalg.solve(matrix,np.ones(matrix_dim))

n_iter = 100
chunksize = 10
p = Pool(n_processes)
p.map(test_function,range(n_iter),chunksize=chunksize)
[/code]
Dies gibt 8 Prozesse, die alle 100% CPU verwenden, sodass es kein knappes Problem zu sein scheint. Bearbeiten: Nicht immer, ich sehe manchmal das gleiche Verhalten wie oben beschrieben, wobei 8 Prozesse jeweils 25% CPU verwenden. Und das Testen verschiedener Werte von n_processes zwischen 1 und 8, es wird kein Leistungsunterschied ersichtlich. Ich führe all dies in einer virtuellen Konda-Env mit Python 3.11 auf Ubuntu 22.04 aus. 2,80 GHz < /p>

Ausgabe von hwloc -ps -t < /code> Wenn das Programm ausgeführt wird: < /p>
[code]142024 Core:0 python
142025 Core:0 python
142026 Core:0 python
142027 Core:0 python
142028 Core:0 python
142029 Core:0 python
142030 Core:0 python
142031 Core:0 python
[/code]

Ausgabe von hwloc-ls : screenshot von hwloc-ls Ausgabe