Ecrire une boucle parallèle

Je suis en train de lancer une boucle parallèle sur un exemple simple.
Ce que je fais mal?

from joblib import Parallel, delayed  
import multiprocessing

def processInput(i):  
        return i * i

if __name__ == '__main__':

    # what are your inputs, and what operation do you want to 
    # perform on each input. For example...
    inputs = range(1000000)      

    num_cores = multiprocessing.cpu_count()

    results = Parallel(n_jobs=4)(delayed(processInput)(i) for i in inputs) 

    print(results)

Le problème avec le code, c'est que lorsqu'il est exécuté sous les environnements Windows en Python 3, il s'ouvre num_cores instances de python pour exécuter les tâches parallèles, mais un seul est actif. Cela ne devrait pas être le cas puisque l'activité du processeur doit être de 100% au lieu de 14% (en vertu de l'i7 - 8 logique de cœurs).

Pourquoi sont les instances de ne pas faire quelque chose?

source d'informationauteur KMA

  1. 18

    De continuer sur votre demande de fournir un travail de multitraitement de code, je vous suggère d'utiliser pool_map (si le retard de la fonctionnalité n'est pas important), je vais vous donner un exemple, si votre e travail sur python3 sa vaut la peine de mentionner que vous pouvez utiliser starmap.
    Également intéressant de mentionner que vous pouvez utiliser map_sync/starmap_async si l'ordre des résultats obtenus n'ont pas à correspondre à l'ordre des entrées.

    import multiprocessing as mp

def processInput(i):
        return i * i

if __name__ == '__main__':

    # what are your inputs, and what operation do you want to
    # perform on each input. For example...
    inputs = range(1000000)
    #  removing processes argument makes the code run on all available cores
    pool = mp.Pool(processes=4)
    results = pool.map(processInput, inputs)
    print(results)
  2. 3

    Sur Windows, le multitraitement module utilise le "spawn" méthode " pour le démarrage de plusieurs interpréteur python processus. C'est relativement lente. En parallèle essaie d'être intelligent sur l'exécution du code. En particulier, il tente d'ajuster les tailles de lot donc un lot prend environ une demi-seconde à exécuter. (Voir la batch_size argument à https://pythonhosted.org/joblib/parallel.html)

    Votre processInput() fonction de courir aussi vite que le Parallèle détermine qu'il est plus rapide à exécuter les travaux en série sur un seul processeur que de faire tourner plusieurs interpréteurs python et exécuter le code en parallèle.

    Si vous voulez forcer votre exemple pour s'exécuter sur plusieurs cœurs, essayez de définir batch_size à 1000 ou faire processInput() plus compliqué donc il faut plus de temps pour s'exécuter.

    Edit: exemple de Travail sur windows, qui montre plusieurs processus en cours d'utilisation (je suis sous windows 7):

    from joblib import Parallel, delayed
from os import getpid

def modfib(n):
    # print the process id to see that multiple processes are used, and
    # re-used during the job.
    if n%400 == 0:
        print(getpid(), n)  

    # fibonacci sequence mod 1000000
    a,b = 0,1
    for i in range(n):
        a,b = b,(a+b)%1000000
    return b

if __name__ == "__main__":
    Parallel(n_jobs=-1, verbose=5)(delayed(modfib)(j) for j in range(1000, 4000))