Python multitraitement: Comment savoir à l'utilisation de la Piscine ou Processus?

J'ai donc un algorithme que je suis en train d'écrire, et la fonction multiprocess est censé appeler une autre fonction, CreateMatrixMp(), comme de nombreux processus comme il y a des processeurs en parallèle. Je n'ai jamais fait de multitraitement avant, et ne peut pas être sûr de l'une des méthodes ci-dessous est plus efficace. Le mot "efficace" dans le contexte de la fonction CreateMatrixMp() avoir besoin d'être potentiellement des milliers de fois.J'ai tout lu de la documentation sur le python multiprocessing module, et en sont venus à ces deux possibilités:

Première est l'aide de l' Pool classe:

def MatrixHelper(self, args):
    return self.CreateMatrix(*args)

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)
    poolCount = cpus*2
    args = [(sigmaI, sigmaX, i) for i in range(self.numPixels)]

    pool = mp.Pool(processes = poolCount, maxtasksperchild= 2)
    tempData = pool.map(self.MatrixHelper, args)
    pool.close()
    pool.join()

Et la prochaine est à l'aide de la Process classe:

def Multiprocess(self, sigmaI, sigmaX):

    cpus = mp.cpu_count()
    print('Number of cpu\'s to process WM: %d' % cpus)

    processes = [mp.Process(target = self.CreateMatrixMp, args = (sigmaI, sigmaX, i,)) for i in range(self.numPixels)]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

Pool semble être le meilleur choix. J'ai lu que cela entraîne moins de frais généraux. Et Process ne prend pas en compte le nombre de processeurs de la machine. Le seul problème est que l'utilisation de Pool de cette manière me donne l'erreur après erreur, et quand je le résoudre, il ya un nouveau-dessous. Process semble plus facile à mettre en œuvre, et pour tout ce que je sais, il peut être le meilleur choix. Qu'est-ce que votre expérience vous dire?

Si Pool doit être utilisé, puis je suis droit dans le choix de map()? Il serait préférable que l'ordre est maintenu. J'ai tempData = pool.map(...) parce que le map fonction est supposée retourner une liste des résultats de tous les processus. Je ne suis pas sûr de savoir comment Process gère ses données renvoyées.

Cela semble similaire au stackoverflow.com/questions/18176178/... Merci
J'ai lu ce poste. Cependant, je demande à certains différentes questions auxquelles il faut répondre. Il est à l'aide de deux fonctions cible alors que je suis en utiliser un, il passe pas d'arguments alors que je passe plusieurs, et il n'a pas à être préoccupés avec sa cible étant une méthode d'instance, comme la mienne. J'ai fait beaucoup de recherches sur cette mesure, et les deux Pool et Process semblent se comporter différemment dans des contextes différents, et il semble bien que l'on serait mieux dans certaines situations, tandis que dans d'autres, il ne serait pas. J'ai pensé qu'il était approprié de commencer une nouvelle question.

OriginalL'auteur Anonymous | 2015-07-29

12

Je pense que le Pool classe est généralement plus commode, mais cela dépend si vous voulez que vos résultats ordonné ou désordonné.

Que vous voulez créer des 4 chaînes aléatoires (e.g,. pourrait être un hasard ID d'utilisateur ou générateur):
```
import multiprocessing as mp
import random
import string

# Define an output queue
output = mp.Queue()

# define a example function
def rand_string(length, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
               for i in range(length))
    output.put(rand_str)

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, output)) for x in range(4)]

# Run processes
for p in processes:
    p.start()

# Exit the completed processes
for p in processes:
    p.join()

# Get process results from the output queue
results = [output.get() for p in processes]

print(results)

# Output
# ['yzQfA', 'PQpqM', 'SHZYV', 'PSNkD']
```
Ici, l'ordre n'a probablement pas d'importance. Je ne suis pas sûr si il ya une meilleure façon de le faire, mais si je veux garder une trace des résultats dans l'ordre dans lequel les fonctions sont appelées, en général, je retourner des tuples avec un ID comme premier élément, par exemple,
```
# define a example function
def rand_string(length, pos, output):
    """ Generates a random string of numbers, lower- and uppercase chars. """
    rand_str = ''.join(random.choice(
                    string.ascii_lowercase
                    + string.ascii_uppercase
                    + string.digits)
                for i in range(length))
    output.put((pos, rand_str))

# Setup a list of processes that we want to run
processes = [mp.Process(target=rand_string, args=(5, x, output)) for x in range(4)]

print(processes)

# Output
# [(1, '5lUya'), (3, 'QQvLr'), (0, 'KAQo6'), (2, 'nj6Q0')]
```
Ce laissez-moi trier les résultats:
```
results.sort()
results = [r[1] for r in results]
print(results)

# Output:
# ['KAQo6', '5lUya', 'nj6Q0', 'QQvLr']
```
La Piscine de la classe

Maintenant à votre question: Comment est-ce différent de la Pool classe?
Vous devez généralement préfèrent Pool.map retour liste ordonnée des résultats sans passer à travers le cerceau de la création de tuples et les trier par ID. Donc, je dirais qu'il est généralement plus efficace.
```
def cube(x):
    return x**3

pool = mp.Pool(processes=4)
results = pool.map(cube, range(1,7))
print(results)

# output:
# [1, 8, 27, 64, 125, 216]
```
De manière équivalente, il y a aussi un "appliquer" la méthode:
```
pool = mp.Pool(processes=4)
results = [pool.apply(cube, args=(x,)) for x in range(1,7)]
print(results)

# output:
# [1, 8, 27, 64, 125, 216]
```
Les deux Pool.apply et Pool.map de verrouillage, le programme principal jusqu'à ce qu'un processus est terminé.

Maintenant, vous avez également Pool.apply_async et Pool.map_async, qui retournent le résultat dès que le processus est terminé, ce qui est essentiellement similaire à la Process classe au-dessus. L'avantage peut être qu'ils vous fournissent avec la pratique apply et map fonctionnalités que vous savez à partir de Python intégré apply et map

Merci pour la réponse. Ma principale préoccupation dans le choix de l'un sur l'autre est la contrepartie des machines nombre de processeurs. Dans la Piscine, vous pouvez le configurer de sorte qu'il y a le même nombre de processus de processeurs. Mais en utilisant Process, le nombre de cpu vient de nulle part. Cette question sera traitée sur son propre? Sera-ce un peu plus de temps pour passer à travers en utilisant Process? Je voudrais utiliser Process, et Pool est de me donner un moment très difficile avec tous ses pickle erreurs, mais Process juste ne se sent pas assez concret comme Pool.
Je pense que "Processus" est plus un "bare bones" approche, autant que je sache, vous aurez à gérer manuellement. Lorsque vous frayer un processus, mais tous les Processeurs sont occupés, il sera mis en file d'attente jusqu'à ce qu'un CPU devient à nouveau libre. Cela pourrait être un problème si vous envoi un trop grand nombre de processus à la fois qui sont en attente (il pourrait prendre facilement votre système de mémoire disponible si le nombre est "relativement" large)
Oui, la mémoire est un problème lorsque vous essayez d'utiliser Process. J'ai eu à travailler avec Pool, je vous remercie pour vos conseils, je vais donner une réponse.

OriginalL'auteur Sebastian

Vous devez vous connecter pour publier un commentaire.

La Piscine de la classe