Je voulais enregistrer un graphique de certaines données de mesure (csv) au format PDF. Lorsque le nombre de données était important (1000 données), cela prenait beaucoup de temps (environ 8 minutes), j'ai donc pensé à l'améliorer.
Je souhaite enregistrer une grande quantité de PDF à grande vitesse et éviter que le PC ne reste bloqué pendant le fonctionnement.
J'ai principalement fait ce qui suit en utilisant python.
Boucle For normalement en python
Treading
J'avais de l'expérience dans sa mise en œuvre pour diverses raisons, alors je l'ai essayé → Il semble que la vitesse ne change pas beaucoup car ce type ne peut utiliser qu'un seul noyau. Pourtant, il est surprenant que 4 minutes changent
multiprocessing.Process
Étant donné que la fonction que je souhaite traiter en parallèle a plusieurs arguments, j'ai utilisé Process. Cependant, peu importe combien de gg j'ai fait, je ne savais pas comment limiter le nombre de threads, donc je ne pouvais pas l'implémenter. Pour cette raison, lorsque je l'ai exécuté, il a traité 1000 processus parallèles, ce qui a rendu mon PC en désordre.
multiprocessing.Pool
Il ne peut avoir qu'un seul argument, mais vous pouvez facilement spécifier le nombre de threads. Les fonctions suivantes peuvent être utilisées pour plusieurs arguments.
def wrapper(self, args):
return self.f(*args)
Le codage du multitraitement est OK si vous procédez comme suit. C'est la configuration minimale (il n'y a pas de sens de parallélisation) qui montre seulement comment coder. Pour plus de détails, reportez-vous à cet article. J'ai étudié en profondeur le traitement parallèle et le traitement parallèle de Python --Qiita
from multiprocessing import Process, Pool
import multiprocessing
def f(a, b): #Fonctions à traiter en parallèle
print(a, end=",") #C'est juste un contrôle de fonctionnement, donc c'est simple
def wrapper(args): #La piscine ne peut accepter qu'un seul argument, alors mordez-la et développez-la.
f(*args)
def main():
#Traitement parallèle par processus(Arguments multiples: o,Nombre de processus spécifié: x)
print('Process')
p_list = []
for i in range(20):
p = Process(
target=f,
kwargs={'a': i, 'b': 0})
p.start() #début
p_list.append(p)
for p in p_list:
p.join() #Attends la fin
#Traitement parallèle par Pool(Arguments multiples: x,Nombre de processus spécifié: o)
print('\nPool')
p = Pool(multiprocessing.cpu_count()) #Traitement parallèle pour le nombre de CPU
values = []
for i in range(20):
values.append((i, 0))
p.map(wrapper, values) #Développer un argument unique en plusieurs
if __name__ == "__main__":
main()
résultat
Process
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
Pool
6,0,8,14,2,10,16,3,11,17,5,13,18,1,9,15,4,12,19,7,
Le classement est le suivant.
Comparez 1 et 2. En 1., le processus se déroulera dans l'ordre de 8 pièces.
En 2., tous les traitements (1000 traitements cette fois) seront effectués en parallèle.
―― N'est-ce pas censé être 2. plus rapide? En fait, la CPU ne peut pas traiter en parallèle en principe. Ce qui semble être un traitement parallèle ne fait que changer ce que vous faites. Par exemple, le traitement parallèle des processus 1, 2 et 3 Process 1 (exécution 1 μs) → Process 2 (exécution 1 μs) → Process 3 (exécution 1 μs) → Process 1 (exécution 1 μs à partir de la suite de l'étape précédente) → ... Il prétend juste être en parallèle. Donc Processus 1 (exécuter jusqu'à la fin) → Process 2 (exécuter jusqu'à la fin) → Process 3 (exécuter jusqu'à la fin) Cependant, en principe, l'heure ne change pas. (Quelquefois) Cependant, comme le traitement parallèle peut être effectué pour le nombre de cœurs (nombre de processeurs), le traitement sera plus rapide jusque-là.
――Pourquoi êtes-vous allé plus vite? Est-ce parce que vous pouvez utiliser beaucoup de mémoire? En 2., 1000 processus sont exécutés, donc la mémoire devient encombrée. N'est-ce pas parce qu'il s'est amélioré?
Recommended Posts