Python multiprocessing Pool process limit
Lors de l'utilisation de l'objet Pool à partir du module de multitraitement, le nombre de processus est-il limité par le nombre de cœurs de processeur? Par exemple. si j'ai 4 cœurs, même si je crée un pool avec 8 processus, seulement 4 fonctionneront en même temps?
Vous pouvez demander autant de processus que vous le souhaitez. Toute limite qui pourrait exister sera imposée par votre système d'exploitation, et non par multiprocessing. Par exemple,
p = multiprocessing.Pool(1000000)
est susceptible de subir une mort laide sur n'importe quelle machine. J'essaye sur ma boîte pendant que je tape ceci, et le système d'exploitation réduit mon disque en un échange de poussière RAM follement - l'a finalement tué après avoir créé environ 3000 processus ;-)
Quant au nombre d'exécutions "simultanées", Python n'a pas son mot à dire. Cela dépend de:
- Combien votre matériel est capable de fonctionner simultanément; et,
- Comment votre système d'exploitation décide de donner des ressources matérielles à tous les processus sur votre machine en cours d'exécution.
Pour les tâches liées au processeur, il n'est pas logique de créer plus de processus Pool que vous n'avez de cœurs pour les exécuter. Si vous essayez également d'utiliser votre machine à d'autres fins, vous devez créer moins de processus que de cœurs.
Pour les tâches liées aux E/S, il peut avoir un sens pour créer un nombre de processus Pool plus important que les cœurs, car les processus passera probablement la majeure partie de son temps bloqué (en attendant la fin des E/S).
Oui. Théoriquement, il n'y a pas de limite sur les processus que vous pouvez créer, mais une quantité folle de processus démarrés à la fois entraînera la mort du système en raison de la mémoire insuffisante. Notez que les processus occupent une empreinte beaucoup plus grande que les threads car ils n'utilisent pas d'espace partagé entre eux mais utilisent un espace individuel pour chaque processus.
la meilleure pratique de programmation est donc d'utiliser un sémaphore limité au nombre de processeurs de votre système. probable
pool = multiprocessing.Semaphore(4) # no of cpus of your system.
Si vous n'êtes pas au courant du nombre de cœurs de votre système ou si vous souhaitez utiliser le code dans de nombreux systèmes, un code générique comme ci-dessous fera l'affaire ...
pool = multiprocessing.Semaphore(multiprocessing.cpu_count())
#this will detect the number of cores in your system and creates a semaphore with that value.
P.S. Mais il est bon d'utiliser toujours le nombre de cœurs-1.
J'espère que cela t'aides :)
Bien qu'il n'y ait aucune limite que vous pouvez définir, si vous cherchez à comprendre un nombre pratique à utiliser pour les processus liés au processeur (que je soupçonne que vous recherchez ici), vous pouvez exécuter ce qui suit:
>>> import multiprocessing
>>> multiprocessing.cpu_count()
1
Quelques bonnes notes sur les limitations (en particulier sous Linux) sont notées dans la réponse ici :
C'est exact. Si vous avez 4 cœurs, 4 processus peuvent être exécutés simultanément. N'oubliez pas que vous avez des éléments système qui doivent continuer et qu'il serait bien que vous définissiez le numéro de processus comme number_of_cores - 1. Il s'agit d'une préférence et non obligatoire. Pour chaque processus que vous créez, il y a une surcharge, vous utilisez donc plus de mémoire pour ce faire. Mais si RAM n'est pas un problème, allez-y. Si vous utilisez Cuda ou une autre bibliothèque basée sur GPU, vous avez un paradigme différent, mais c'est pour une autre question.