Joblib Parallèle de plusieurs cpu est plus lent que seul

En bref: je ne peux pas reproduire votre problème. Si vous êtes sur Windows, vous devez utiliser un protecteur pour votre boucle principale: la documentation de joblib.En parallèle. Le seul problème que je vois, c'est beaucoup de copie de données dessus, mais vos chiffres semblent irréalistes être causé par l'.

En long, voici mes synchronisations avec votre code:

Sur mon i7 3770k (4 coeurs, 8 threads) j'obtiens les résultats suivants pour les différents n_jobs:

For-loop: Finished in 33.8521318436 sec
n_jobs=1: Finished in 33.5527760983 sec
n_jobs=2: Finished in 18.9543449879 sec
n_jobs=3: Finished in 13.4856410027 sec
n_jobs=4: Finished in 15.0832719803 sec
n_jobs=5: Finished in 14.7227740288 sec
n_jobs=6: Finished in 15.6106669903 sec

Il y a donc un gain dans l'utilisation de plusieurs processus. Cependant, bien que j'ai quatre coeurs, le gain déjà sature à trois processus. Donc je suppose que le temps d'exécution est limitée par l'accès à la mémoire plutôt que de temps processeur.

Vous devriez noter que les arguments de chaque boucle d'entrée sont copiés dans le processus de l'exécution d'elle. Cela signifie que vous copie a pour chaque élément dans b. C'est inefficace. Ainsi, au lieu de l'accès mondial a. (Parallel déviera le processus, la copie de toutes les variables globales pour le nouvellement généré des processus, de sorte a est accessible). Cela me donne le code suivant (avec calendrier et la boucle principale de la garde que la documentation de joblib recommande:

import numpy as np
from matplotlib.path import Path
from joblib import Parallel, delayed
import time
import sys

## Check if one line segment contains another. 

def check_paths(path):
    for other_path in a:
        res='no cross'
        chck = Path(other_path)
        if chck.contains_path(path)==1:
            res= 'cross'
            break
    return res

if __name__ == '__main__':
    ## Create pairs of points for line segments
    a = zip(np.random.rand(5000,2),np.random.rand(5000,2))
    b = zip(np.random.rand(300,2),np.random.rand(300,2))

    now = time.time()
    if len(sys.argv) >= 2:
        res = Parallel(n_jobs=int(sys.argv[1])) (delayed(check_paths) (Path(points)) for points in b)
    else:
        res = [check_paths(Path(points)) for points in b]
    print "Finished in", time.time()-now , "sec"

Calendrier résultats:

 n_jobs=1: Finished in 34.2845709324 sec
 n_jobs=2: Finished in 16.6254048347 sec
 n_jobs=3: Finished in 11.219119072 sec
 n_jobs=4: Finished in 8.61683392525 sec
 n_jobs=5: Finished in 8.51907801628 sec
 n_jobs=6: Finished in 8.21842098236 sec
 n_jobs=7: Finished in 8.21816396713 sec
 n_jobs=8: Finished in 7.81841087341 sec

La saturation maintenant légèrement déplacé vers n_jobs=4 qui est la valeur attendue.

check_paths effectue plusieurs calculs redondants qui peuvent facilement être éliminés. Tout d'abord pour tous les éléments de other_paths=a la ligne Path(...) est exécuté lors de chaque appel. Précalculer que. Deuxièmement, la chaîne res='no cross' est écrit dans chaque boucle son tour, bien qu'il ne peut changer une fois (suivie d'une pause et de retour). Déplacer la ligne en face de la boucle. Ensuite, le code ressemble à ceci:

import numpy as np
from matplotlib.path import Path
from joblib import Parallel, delayed
import time
import sys

## Check if one line segment contains another. 

def check_paths(path):
    #global a
    #print(path, a[:10])
    res='no cross'
    for other_path in a:
        if other_path.contains_path(path)==1:
            res= 'cross'
            break
    return res

if __name__ == '__main__':
    ## Create pairs of points for line segments
    a = zip(np.random.rand(5000,2),np.random.rand(5000,2))
    a = [Path(x) for x in a]

    b = zip(np.random.rand(300,2),np.random.rand(300,2))

    now = time.time()
    if len(sys.argv) >= 2:
        res = Parallel(n_jobs=int(sys.argv[1])) (delayed(check_paths) (Path(points)) for points in b)
    else:
        res = [check_paths(Path(points)) for points in b]
    print "Finished in", time.time()-now , "sec"

avec des timings:

n_jobs=1: Finished in 5.33742594719 sec
n_jobs=2: Finished in 2.70858597755 sec
n_jobs=3: Finished in 1.80810618401 sec
n_jobs=4: Finished in 1.40814709663 sec
n_jobs=5: Finished in 1.50854086876 sec
n_jobs=6: Finished in 1.50901818275 sec
n_jobs=7: Finished in 1.51030707359 sec
n_jobs=8: Finished in 1.51062297821 sec

Un côté noeud sur votre code, même si je n'ai pas vraiment suivi son but, ce n'était pas liée à votre question, contains_path ne retour True if this path completely contains the given path. (voir la documentation). Par conséquent, votre fonction sera toujours, fondamentalement, un retour no cross compte tenu de l'aléatoire d'entrée.